From 1c91d5435a5d9359df067763a781b6f1d760b3bb Mon Sep 17 00:00:00 2001
From: samatstarion <s.gerene@stariongroup.eu>
Date: Sat, 7 Mar 2026 16:51:04 +0100
Subject: [PATCH 1/9] [WIP] add serializer class and improce ISerializer
 interface

---
 .gitignore                                    |  1 +
 .../SerializerTestFixture.cs                  | 54 +++++++++++
 SysML2.NET.Serializer.Xmi/ISerializer.cs      | 50 ++--------
 SysML2.NET.Serializer.Xmi/Serializer.cs       | 95 +++++++++++++++++++
 4 files changed, 160 insertions(+), 40 deletions(-)
 create mode 100644 SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Serializer.cs

diff --git a/.gitignore b/.gitignore
index 3cdf4d79f..3f8b414be 100644
--- a/.gitignore
+++ b/.gitignore
@@ -355,3 +355,4 @@ MigrationBackup/
 # WinMerge bak files
 *.bak
 /switcher.json
+/.claude/settings.local.json
diff --git a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
new file mode 100644
index 000000000..16ebc2198
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
@@ -0,0 +1,54 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SerializerTestFixture.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2026 Starion Group S.A.
+// 
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+// 
+//        http://www.apache.org/licenses/LICENSE-2.0
+// 
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// 
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Tests
+{
+    using System;
+    using System.IO;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    using Microsoft.Extensions.DependencyInjection;
+    using Microsoft.Extensions.Logging;
+
+    using SysML2.NET.Serializer.Xmi.Extensions;
+    using SysML2.NET.Serializer.Xmi.Readers;
+
+    [TestFixture]
+    public class SerializerTestFixture
+    {
+        private Serializer serializer;
+        private XmiDataCache xmiDataCache;
+
+        [SetUp]
+        public void Setup()
+        {
+            var serviceProvider = new ServiceCollection()
+                .AddLogging(x => x.AddConsole())
+                .BuildServiceProvider();
+
+            this.xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(),serviceProvider.GetRequiredService<ILogger<XmiDataCache>>());
+
+            this.serializer = new Serializer(serviceProvider.GetRequiredService<ILoggerFactory>());
+        }
+        
+        
+    }
+}
diff --git a/SysML2.NET.Serializer.Xmi/ISerializer.cs b/SysML2.NET.Serializer.Xmi/ISerializer.cs
index 1ea7c6ce9..b80194b7e 100644
--- a/SysML2.NET.Serializer.Xmi/ISerializer.cs
+++ b/SysML2.NET.Serializer.Xmi/ISerializer.cs
@@ -26,18 +26,19 @@ namespace SysML2.NET.Serializer.Xmi
     using System.Threading.Tasks;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
 
     /// <summary>
-    /// The purpose of the <see cref="ISerializer"/> is to write an <see cref="IData"/> and <see cref="IEnumerable{IData}"/>
+    /// The purpose of the <see cref="ISerializer"/> is to write an <see cref="INamespace"/>
     /// as XMI to a <see cref="Stream"/>
     /// </summary>
     public interface ISerializer
     {
         /// <summary>
-        /// Serialize an <see cref="IEnumerable{IData}"/> as XMI to a target <see cref="Stream"/>
+        /// Serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>
         /// </summary>
-        /// <param name="dataItems">
-        /// The <see cref="IEnumerable{IData}"/> that shall be serialized
+        /// <param name="namespace">
+        /// The <see cref="INamespace"/> that shall be serialized
         /// </param>
         /// <param name="includeDerivedProperties">
         /// Asserts that derived properties should also be part of the serialization
@@ -45,27 +46,13 @@ public interface ISerializer
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
-        void Serialize(IEnumerable<IData> dataItems, bool includeDerivedProperties, Stream stream);
+        void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream);
 
         /// <summary>
-        /// Serialize an <see cref="IData"/> as XMI to a target <see cref="Stream"/>
+        /// Asynchronously serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>
         /// </summary>
-        /// <param name="dataItem">
-        /// The <see cref="IData"/> that shall be serialized
-        /// </param>
-        /// <param name="includeDerivedProperties">
-        /// Asserts that derived properties should also be part of the serialization
-        /// </param>
-        /// <param name="stream">
-        /// The target <see cref="Stream"/>
-        /// </param>
-        void Serialize(IData dataItem, bool includeDerivedProperties, Stream stream);
-
-        /// <summary>
-        /// Asynchronously serialize an <see cref="IEnumerable{IData}"/> as XMI to a target <see cref="Stream"/>
-        /// </summary>
-        /// <param name="dataItems">
-        /// The <see cref="IEnumerable{IData}"/> that shall be serialized
+        /// <param name="namespace">
+        /// The <see cref="INamespace"/> that shall be serialized
         /// </param>
         /// <param name="stream">
         /// The target <see cref="Stream"/>
@@ -76,23 +63,6 @@ public interface ISerializer
         /// <param name="cancellationToken">
         /// The <see cref="CancellationToken"/> used to cancel the operation
         /// </param>
-        Task SerializeAsync(IEnumerable<IData> dataItems, bool includeDerivedProperties, Stream stream, CancellationToken cancellationToken);
-
-        /// <summary>
-        /// Asynchronously serialize an <see cref="IData"/> as XMI to a target <see cref="Stream"/>
-        /// </summary>
-        /// <param name="dataItem">
-        /// The <see cref="IData"/> that shall be serialized
-        /// </param>
-        /// <param name="includeDerivedProperties">
-        /// Asserts that derived properties should also be part of the serialization
-        /// </param>
-        /// <param name="stream">
-        /// The target <see cref="Stream"/>
-        /// </param>
-        /// <param name="cancellationToken">
-        /// The <see cref="CancellationToken"/> used to cancel the operation
-        /// </param>
-        Task SerializeAsync(IData dataItem, bool includeDerivedProperties, Stream stream, CancellationToken cancellationToken);
+        Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, Stream stream, CancellationToken cancellationToken);
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Serializer.cs b/SysML2.NET.Serializer.Xmi/Serializer.cs
new file mode 100644
index 000000000..ef14ce614
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Serializer.cs
@@ -0,0 +1,95 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="Serializer.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2026 Starion Group S.A.
+// 
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+// 
+//        http://www.apache.org/licenses/LICENSE-2.0
+// 
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// 
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi
+{
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Threading;
+    using System.Threading.Tasks;
+    
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+    
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+
+    /// <summary>
+    /// The purpose of the <see cref="ISerializer"/> is to write an <see cref="INamespace"/>
+    /// as XMI to a <see cref="Stream"/>
+    /// </summary>
+    public class Serializer : ISerializer
+    {
+        /// <summary>
+        /// The injected <see cref="ILogger{Serializer}" /> to produce logs statement
+        /// </summary>
+        private readonly ILogger<Serializer> logger;
+
+        /// <summary>
+        /// The injected <see cref="ILoggerFactory " /> used to set up logging
+        /// </summary>
+        private readonly ILoggerFactory loggerFactory;
+        
+        /// <summary>Initializes a new instance of the <see cref="Serializer"></see> class.</summary>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory " /> used to set up logging</param>
+        public Serializer(ILoggerFactory loggerFactory)
+        {
+            this.loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
+            this.logger = this.loggerFactory.CreateLogger<Serializer>();
+        }
+        
+        /// <summary>
+        /// Serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>
+        /// </summary>
+        /// <param name="namespace">
+        /// The <see cref="INamespace"/> that shall be serialized
+        /// </param>
+        /// <param name="includeDerivedProperties">
+        /// Asserts that derived properties should also be part of the serialization
+        /// </param>
+        /// <param name="stream">
+        /// The target <see cref="Stream"/>
+        /// </param>
+        public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        /// <summary>
+        /// Asynchronously serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>
+        /// </summary>
+        /// <param name="namespace">
+        /// The <see cref="INamespace"/> that shall be serialized
+        /// </param>
+        /// <param name="stream">
+        /// The target <see cref="Stream"/>
+        /// </param>
+        /// <param name="includeDerivedProperties">
+        /// Asserts that derived properties should also be part of the serialization
+        /// </param>
+        /// <param name="cancellationToken">
+        /// The <see cref="CancellationToken"/> used to cancel the operation
+        /// </param>
+        public Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, Stream stream, CancellationToken cancellationToken)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}

From 66d01b9a7056e665d5a9986b591085d3d771d454 Mon Sep 17 00:00:00 2001
From: samatstarion <s.gerene@stariongroup.eu>
Date: Sat, 7 Mar 2026 18:18:03 +0100
Subject: [PATCH 2/9] [Add] serializer test fixture and some implementation
 notes

---
 .../SerializerTestFixture.cs                  | 28 ++++++++++++++++---
 SysML2.NET.Serializer.Xmi/Serializer.cs       |  8 +++++-
 2 files changed, 31 insertions(+), 5 deletions(-)

diff --git a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
index 16ebc2198..fb5951346 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
@@ -24,18 +24,21 @@ namespace SysML2.NET.Serializer.Xmi.Tests
     using System.IO;
     using System.Threading;
     using System.Threading.Tasks;
-
+    using Core.POCO.Root.Namespaces;
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.Logging;
 
     using SysML2.NET.Serializer.Xmi.Extensions;
     using SysML2.NET.Serializer.Xmi.Readers;
-
+    
     [TestFixture]
     public class SerializerTestFixture
     {
         private Serializer serializer;
+        private DeSerializer deSerializer;
         private XmiDataCache xmiDataCache;
+        
+        private INamespace anonymouseNameSpace;
 
         [SetUp]
         public void Setup()
@@ -46,9 +49,26 @@ public void Setup()
 
             this.xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(),serviceProvider.GetRequiredService<ILogger<XmiDataCache>>());
 
+            this.deSerializer = new DeSerializer(new ExternalReferenceService(serviceProvider.GetRequiredService<ILogger<ExternalReferenceService>>()), new XmiDataReaderFacade(), this.xmiDataCache, serviceProvider.GetRequiredService<ILoggerFactory>());
+
+            this.ReadAndAssemblePopulationFromXmiFile();
+            
             this.serializer = new Serializer(serviceProvider.GetRequiredService<ILoggerFactory>());
         }
-        
-        
+
+        [Test]
+        public void Verify_that_the_name_space_can_be_serialized_to_xmi()
+        {
+            var targetStream = new MemoryStream();
+            
+            Assert.That(() => this.serializer.Serialize(this.anonymouseNameSpace, false,targetStream), Throws.Nothing);
+            
+        }
+
+        private void ReadAndAssemblePopulationFromXmiFile()
+        {
+            var filePath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "Domain Libraries", "Quantities and Units", "Quantities.sysmlx");
+            this.anonymouseNameSpace = this.deSerializer.DeSerialize(new Uri(filePath));
+        }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Serializer.cs b/SysML2.NET.Serializer.Xmi/Serializer.cs
index ef14ce614..03bf985a3 100644
--- a/SysML2.NET.Serializer.Xmi/Serializer.cs
+++ b/SysML2.NET.Serializer.Xmi/Serializer.cs
@@ -69,8 +69,11 @@ public Serializer(ILoggerFactory loggerFactory)
         /// </param>
         public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream)
         {
+            // if the namespace is not an anonymouse namespace, then first create that and make the
+            // provide namespace owned by the anonymouse
+            
             throw new System.NotImplementedException();
-        }
+        }   
 
         /// <summary>
         /// Asynchronously serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>
@@ -89,6 +92,9 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stre
         /// </param>
         public Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, Stream stream, CancellationToken cancellationToken)
         {
+            // if the namespace is not an anonymouse namespace, then first create that and make the
+            // provide namespace owned by the anonymouse
+            
             throw new System.NotImplementedException();
         }
     }

From 20406381e76803f96b8f253e9b8bda5c31e2fddb Mon Sep 17 00:00:00 2001
From: samatstarion <s.gerene@stariongroup.eu>
Date: Sat, 7 Mar 2026 22:36:50 +0100
Subject: [PATCH 3/9] [Add] XmiElementOriginMap to track from which xmi file an
 IElement was sourced

[Add] first implementatino of the XMI serializer
---
 .../UmlCoreXmiWriterGenerator.cs              |  137 ++
 ...mi-reader-partial-for-element-template.hbs |    4 +-
 ...-writer-partial-for-attribute-template.hbs |   29 +
 .../Uml/core-xmi-reader-facade-template.hbs   |   38 +-
 .../Uml/core-xmi-reader-template.hbs          |    7 +-
 .../Uml/core-xmi-writer-template.hbs          |  115 ++
 .../RoundTripTestFixture.cs                   |  154 ++
 .../SerializerTestFixture.cs                  |   56 +-
 .../XmiElementOriginMapTestFixture.cs         |  126 ++
 SysML2.NET.Serializer.Xmi/DeSerializer.cs     |   78 +-
 SysML2.NET.Serializer.Xmi/IDeSerializer.cs    |   33 +
 SysML2.NET.Serializer.Xmi/ISerializer.cs      |   41 +-
 .../IXmiElementOriginMap.cs                   |   73 +
 .../AutoGenReaders/AcceptActionUsageReader.cs |   14 +-
 .../AutoGenReaders/ActionDefinitionReader.cs  |   14 +-
 .../AutoGenReaders/ActionUsageReader.cs       |   14 +-
 .../AutoGenReaders/ActorMembershipReader.cs   |   22 +-
 .../AllocationDefinitionReader.cs             |   22 +-
 .../AutoGenReaders/AllocationUsageReader.cs   |   22 +-
 .../AnalysisCaseDefinitionReader.cs           |   14 +-
 .../AutoGenReaders/AnalysisCaseUsageReader.cs |   14 +-
 .../AutoGenReaders/AnnotatingElementReader.cs |   14 +-
 .../AutoGenReaders/AnnotationReader.cs        |   26 +-
 .../AssertConstraintUsageReader.cs            |   14 +-
 .../AssignmentActionUsageReader.cs            |   14 +-
 .../AutoGenReaders/AssociationReader.cs       |   22 +-
 .../AssociationStructureReader.cs             |   22 +-
 .../AttributeDefinitionReader.cs              |   14 +-
 .../AutoGenReaders/AttributeUsageReader.cs    |   14 +-
 .../Readers/AutoGenReaders/BehaviorReader.cs  |   14 +-
 .../BindingConnectorAsUsageReader.cs          |   22 +-
 .../AutoGenReaders/BindingConnectorReader.cs  |   22 +-
 .../AutoGenReaders/BooleanExpressionReader.cs |   14 +-
 .../CalculationDefinitionReader.cs            |   14 +-
 .../AutoGenReaders/CalculationUsageReader.cs  |   14 +-
 .../AutoGenReaders/CaseDefinitionReader.cs    |   14 +-
 .../Readers/AutoGenReaders/CaseUsageReader.cs |   14 +-
 .../Readers/AutoGenReaders/ClassReader.cs     |   14 +-
 .../AutoGenReaders/ClassifierReader.cs        |   14 +-
 .../AutoGenReaders/CollectExpressionReader.cs |   14 +-
 .../Readers/AutoGenReaders/CommentReader.cs   |   14 +-
 .../AutoGenReaders/ConcernDefinitionReader.cs |   14 +-
 .../AutoGenReaders/ConcernUsageReader.cs      |   14 +-
 .../ConjugatedPortDefinitionReader.cs         |   14 +-
 .../ConjugatedPortTypingReader.cs             |   30 +-
 .../AutoGenReaders/ConjugationReader.cs       |   30 +-
 .../ConnectionDefinitionReader.cs             |   22 +-
 .../AutoGenReaders/ConnectionUsageReader.cs   |   22 +-
 .../Readers/AutoGenReaders/ConnectorReader.cs |   22 +-
 .../ConstraintDefinitionReader.cs             |   14 +-
 .../AutoGenReaders/ConstraintUsageReader.cs   |   14 +-
 .../ConstructorExpressionReader.cs            |   14 +-
 .../AutoGenReaders/CrossSubsettingReader.cs   |   26 +-
 .../Readers/AutoGenReaders/DataTypeReader.cs  |   14 +-
 .../AutoGenReaders/DecisionNodeReader.cs      |   14 +-
 .../AutoGenReaders/DefinitionReader.cs        |   14 +-
 .../AutoGenReaders/DependencyReader.cs        |   30 +-
 .../AutoGenReaders/DifferencingReader.cs      |   26 +-
 .../AutoGenReaders/DisjoiningReader.cs        |   30 +-
 .../AutoGenReaders/DocumentationReader.cs     |   14 +-
 .../ElementFilterMembershipReader.cs          |   22 +-
 .../EndFeatureMembershipReader.cs             |   22 +-
 .../EnumerationDefinitionReader.cs            |   14 +-
 .../AutoGenReaders/EnumerationUsageReader.cs  |   14 +-
 .../EventOccurrenceUsageReader.cs             |   14 +-
 .../AutoGenReaders/ExhibitStateUsageReader.cs |   14 +-
 .../AutoGenReaders/ExpressionReader.cs        |   14 +-
 .../FeatureChainExpressionReader.cs           |   14 +-
 .../AutoGenReaders/FeatureChainingReader.cs   |   26 +-
 .../AutoGenReaders/FeatureInvertingReader.cs  |   30 +-
 .../AutoGenReaders/FeatureMembershipReader.cs |   22 +-
 .../Readers/AutoGenReaders/FeatureReader.cs   |   14 +-
 .../FeatureReferenceExpressionReader.cs       |   14 +-
 .../AutoGenReaders/FeatureTypingReader.cs     |   30 +-
 .../AutoGenReaders/FeatureValueReader.cs      |   22 +-
 .../AutoGenReaders/FlowDefinitionReader.cs    |   22 +-
 .../Readers/AutoGenReaders/FlowEndReader.cs   |   14 +-
 .../Readers/AutoGenReaders/FlowReader.cs      |   22 +-
 .../Readers/AutoGenReaders/FlowUsageReader.cs |   22 +-
 .../ForLoopActionUsageReader.cs               |   14 +-
 .../Readers/AutoGenReaders/ForkNodeReader.cs  |   14 +-
 .../FramedConcernMembershipReader.cs          |   22 +-
 .../Readers/AutoGenReaders/FunctionReader.cs  |   14 +-
 .../AutoGenReaders/IfActionUsageReader.cs     |   14 +-
 .../IncludeUseCaseUsageReader.cs              |   14 +-
 .../AutoGenReaders/IndexExpressionReader.cs   |   14 +-
 .../AutoGenReaders/InteractionReader.cs       |   22 +-
 .../InterfaceDefinitionReader.cs              |   22 +-
 .../AutoGenReaders/InterfaceUsageReader.cs    |   22 +-
 .../AutoGenReaders/IntersectingReader.cs      |   26 +-
 .../Readers/AutoGenReaders/InvariantReader.cs |   14 +-
 .../InvocationExpressionReader.cs             |   14 +-
 .../AutoGenReaders/ItemDefinitionReader.cs    |   14 +-
 .../Readers/AutoGenReaders/ItemUsageReader.cs |   14 +-
 .../Readers/AutoGenReaders/JoinNodeReader.cs  |   14 +-
 .../AutoGenReaders/LibraryPackageReader.cs    |   14 +-
 .../AutoGenReaders/LiteralBooleanReader.cs    |   14 +-
 .../AutoGenReaders/LiteralExpressionReader.cs |   14 +-
 .../AutoGenReaders/LiteralInfinityReader.cs   |   14 +-
 .../AutoGenReaders/LiteralIntegerReader.cs    |   14 +-
 .../AutoGenReaders/LiteralRationalReader.cs   |   14 +-
 .../AutoGenReaders/LiteralStringReader.cs     |   14 +-
 .../AutoGenReaders/MembershipExposeReader.cs  |   26 +-
 .../AutoGenReaders/MembershipImportReader.cs  |   26 +-
 .../AutoGenReaders/MembershipReader.cs        |   26 +-
 .../Readers/AutoGenReaders/MergeNodeReader.cs |   14 +-
 .../Readers/AutoGenReaders/MetaclassReader.cs |   14 +-
 .../MetadataAccessExpressionReader.cs         |   14 +-
 .../MetadataDefinitionReader.cs               |   14 +-
 .../AutoGenReaders/MetadataFeatureReader.cs   |   14 +-
 .../AutoGenReaders/MetadataUsageReader.cs     |   14 +-
 .../AutoGenReaders/MultiplicityRangeReader.cs |   14 +-
 .../AutoGenReaders/MultiplicityReader.cs      |   14 +-
 .../AutoGenReaders/NamespaceExposeReader.cs   |   26 +-
 .../AutoGenReaders/NamespaceImportReader.cs   |   26 +-
 .../Readers/AutoGenReaders/NamespaceReader.cs |   14 +-
 .../AutoGenReaders/NullExpressionReader.cs    |   14 +-
 .../ObjectiveMembershipReader.cs              |   22 +-
 .../OccurrenceDefinitionReader.cs             |   14 +-
 .../AutoGenReaders/OccurrenceUsageReader.cs   |   14 +-
 .../OperatorExpressionReader.cs               |   14 +-
 .../AutoGenReaders/OwningMembershipReader.cs  |   22 +-
 .../Readers/AutoGenReaders/PackageReader.cs   |   14 +-
 .../ParameterMembershipReader.cs              |   22 +-
 .../AutoGenReaders/PartDefinitionReader.cs    |   14 +-
 .../Readers/AutoGenReaders/PartUsageReader.cs |   14 +-
 .../AutoGenReaders/PayloadFeatureReader.cs    |   14 +-
 .../PerformActionUsageReader.cs               |   14 +-
 .../AutoGenReaders/PortConjugationReader.cs   |   30 +-
 .../AutoGenReaders/PortDefinitionReader.cs    |   14 +-
 .../Readers/AutoGenReaders/PortUsageReader.cs |   14 +-
 .../Readers/AutoGenReaders/PredicateReader.cs |   14 +-
 .../AutoGenReaders/RedefinitionReader.cs      |   30 +-
 .../ReferenceSubsettingReader.cs              |   26 +-
 .../AutoGenReaders/ReferenceUsageReader.cs    |   14 +-
 .../RenderingDefinitionReader.cs              |   14 +-
 .../AutoGenReaders/RenderingUsageReader.cs    |   14 +-
 .../RequirementConstraintMembershipReader.cs  |   22 +-
 .../RequirementDefinitionReader.cs            |   14 +-
 .../AutoGenReaders/RequirementUsageReader.cs  |   14 +-
 ...RequirementVerificationMembershipReader.cs |   22 +-
 .../ResultExpressionMembershipReader.cs       |   22 +-
 .../ReturnParameterMembershipReader.cs        |   22 +-
 .../SatisfyRequirementUsageReader.cs          |   14 +-
 .../AutoGenReaders/SelectExpressionReader.cs  |   14 +-
 .../AutoGenReaders/SendActionUsageReader.cs   |   14 +-
 .../AutoGenReaders/SpecializationReader.cs    |   30 +-
 .../StakeholderMembershipReader.cs            |   22 +-
 .../AutoGenReaders/StateDefinitionReader.cs   |   14 +-
 .../StateSubactionMembershipReader.cs         |   22 +-
 .../AutoGenReaders/StateUsageReader.cs        |   14 +-
 .../Readers/AutoGenReaders/StepReader.cs      |   14 +-
 .../Readers/AutoGenReaders/StructureReader.cs |   14 +-
 .../AutoGenReaders/SubclassificationReader.cs |   30 +-
 .../AutoGenReaders/SubjectMembershipReader.cs |   22 +-
 .../AutoGenReaders/SubsettingReader.cs        |   30 +-
 .../AutoGenReaders/SuccessionAsUsageReader.cs |   22 +-
 .../AutoGenReaders/SuccessionFlowReader.cs    |   22 +-
 .../SuccessionFlowUsageReader.cs              |   22 +-
 .../AutoGenReaders/SuccessionReader.cs        |   22 +-
 .../TerminateActionUsageReader.cs             |   14 +-
 .../TextualRepresentationReader.cs            |   14 +-
 .../TransitionFeatureMembershipReader.cs      |   22 +-
 .../AutoGenReaders/TransitionUsageReader.cs   |   14 +-
 .../TriggerInvocationExpressionReader.cs      |   14 +-
 .../AutoGenReaders/TypeFeaturingReader.cs     |   30 +-
 .../Readers/AutoGenReaders/TypeReader.cs      |   14 +-
 .../Readers/AutoGenReaders/UnioningReader.cs  |   26 +-
 .../Readers/AutoGenReaders/UsageReader.cs     |   14 +-
 .../AutoGenReaders/UseCaseDefinitionReader.cs |   14 +-
 .../AutoGenReaders/UseCaseUsageReader.cs      |   14 +-
 .../AutoGenReaders/VariantMembershipReader.cs |   22 +-
 .../VerificationCaseDefinitionReader.cs       |   14 +-
 .../VerificationCaseUsageReader.cs            |   14 +-
 .../AutoGenReaders/ViewDefinitionReader.cs    |   14 +-
 .../ViewRenderingMembershipReader.cs          |   22 +-
 .../Readers/AutoGenReaders/ViewUsageReader.cs |   14 +-
 .../ViewpointDefinitionReader.cs              |   14 +-
 .../AutoGenReaders/ViewpointUsageReader.cs    |   14 +-
 .../WhileLoopActionUsageReader.cs             |   14 +-
 .../AutoGenReaders/XmiDataReaderFacade.cs     | 1352 ++++++++---------
 .../Readers/IXmiDataReaderFacade.cs           |    6 +-
 .../Readers/XmiDataReader.cs                  |    9 +-
 SysML2.NET.Serializer.Xmi/Serializer.cs       |  272 +++-
 .../Writers/IXmiWriter.cs                     |   45 +
 .../Writers/XmiWriter.cs                      |  375 +++++
 .../XmiElementOriginMap.cs                    |  101 ++
 187 files changed, 4121 insertions(+), 1908 deletions(-)
 create mode 100644 SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs
 create mode 100644 SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs
 create mode 100644 SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
 create mode 100644 SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
 create mode 100644 SysML2.NET.Serializer.Xmi.Tests/XmiElementOriginMapTestFixture.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/IXmiElementOriginMap.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/IXmiWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/XmiWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/XmiElementOriginMap.cs

diff --git a/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs b/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs
new file mode 100644
index 000000000..a76459fb6
--- /dev/null
+++ b/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs
@@ -0,0 +1,137 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UmlCoreXmiWriterGenerator.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.CodeGenerator.Generators.UmlHandleBarsGenerators
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+    using System.Threading.Tasks;
+
+    using SysML2.NET.CodeGenerator.Extensions;
+    using SysML2.NET.CodeGenerator.HandleBarHelpers;
+
+    using uml4net.Extensions;
+    using uml4net.StructuredClassifiers;
+    using uml4net.xmi.Readers;
+
+    /// <summary>
+    /// A UML Handlebars based XMI Writer code generator
+    /// </summary>
+    public class UmlCoreXmiWriterGenerator : UmlHandleBarsGenerator
+    {
+        /// <summary>
+        /// Gets the name of the Xmi Writer template
+        /// </summary>
+        private const string XmiWriterTemplateName = "core-xmi-writer-template";
+
+        /// <summary>
+        /// Generates code specific to the concrete implementation
+        /// </summary>
+        /// <param name="xmiReaderResult">
+        /// the <see cref="XmiReaderResult" /> that contains the UML model to generate from
+        /// </param>
+        /// <param name="outputDirectory">
+        /// The target <see cref="DirectoryInfo" />
+        /// </param>
+        /// <returns>
+        /// an awaitable <see cref="Task" />
+        /// </returns>
+        public override async Task GenerateAsync(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory)
+        {
+            await this.GenerateXmiWriters(xmiReaderResult, outputDirectory);
+        }
+
+        /// <summary>
+        /// Generates XMI Writer classes for all concrete <see cref="IClass" />
+        /// </summary>
+        /// <param name="xmiReaderResult">the <see cref="XmiReaderResult" /> that contains the UML model to generate from</param>
+        /// <param name="outputDirectory">
+        /// The target <see cref="DirectoryInfo" />
+        /// </param>
+        /// <returns>
+        /// an awaitable <see cref="Task" />
+        /// </returns>
+        /// <exception cref="ArgumentNullException">
+        /// In case of null value for <paramref name="xmiReaderResult" /> or
+        /// <paramref name="outputDirectory" />
+        /// </exception>
+        private Task GenerateXmiWriters(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory)
+        {
+            ArgumentNullException.ThrowIfNull(xmiReaderResult);
+            ArgumentNullException.ThrowIfNull(outputDirectory);
+
+            return this.GenerateXmiWritersInternal(xmiReaderResult, outputDirectory);
+        }
+
+        /// <summary>
+        /// Generates XMI Writer classes for all concrete <see cref="IClass" />
+        /// </summary>
+        /// <param name="xmiReaderResult">the <see cref="XmiReaderResult" /> that contains the UML model to generate from</param>
+        /// <param name="outputDirectory">
+        /// The target <see cref="DirectoryInfo" />
+        /// </param>
+        /// <returns>
+        /// an awaitable <see cref="Task" />
+        /// </returns>
+        private async Task GenerateXmiWritersInternal(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory)
+        {
+            var template = this.Templates[XmiWriterTemplateName];
+
+            var classes = xmiReaderResult.QueryContainedAndImported("SysML")
+                .SelectMany(x => x.PackagedElement.OfType<IClass>())
+                .Where(x => !x.IsAbstract)
+                .ToList();
+
+            foreach (var umlClass in classes)
+            {
+                var generatedXmiWriter = template(umlClass);
+
+                generatedXmiWriter = this.CodeCleanup(generatedXmiWriter);
+
+                var fileName = $"{umlClass.Name.CapitalizeFirstLetter()}Writer.cs";
+                await WriteAsync(generatedXmiWriter, outputDirectory, fileName);
+            }
+        }
+
+        /// <summary>
+        /// Register the custom helpers
+        /// </summary>
+        protected override void RegisterHelpers()
+        {
+            this.Handlebars.RegisterNamedElementHelper();
+            this.Handlebars.RegisterSafeContextHelper();
+            this.Handlebars.RegisterClassHelper();
+            SysML2.NET.CodeGenerator.HandleBarHelpers.PropertyHelper.RegisterPropertyHelper(this.Handlebars);
+            uml4net.HandleBars.StringHelper.RegisterStringHelper(this.Handlebars);
+            uml4net.HandleBars.ClassHelper.RegisterClassHelper(this.Handlebars);
+            uml4net.HandleBars.PropertyHelper.RegisterPropertyHelper(this.Handlebars);
+        }
+
+        /// <summary>
+        /// Register the code templates
+        /// </summary>
+        protected override void RegisterTemplates()
+        {
+            this.RegisterTemplate(XmiWriterTemplateName);
+            this.RegisterPartialTemplate("core-xmi-writer-partial-for-attribute-template");
+        }
+    }
+}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs
index 96ad1f324..cbdc59d1d 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs
@@ -17,9 +17,9 @@ case"{{String.LowerCaseFirstLetter property.Name}}":
     else
     {
         {{#if asyncState}}
-            var {{String.LowerCaseFirstLetter property.Name}}Value = (I{{property.Type.Name}})await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+            var {{String.LowerCaseFirstLetter property.Name}}Value = (I{{property.Type.Name}})await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
         {{else}}
-            var {{String.LowerCaseFirstLetter property.Name}}Value = (I{{property.Type.Name}})this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+            var {{String.LowerCaseFirstLetter property.Name}}Value = (I{{property.Type.Name}})this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
         {{/if}}
 
         {{#if (Property.QueryIsEnumerable property)}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs
new file mode 100644
index 000000000..663b2a1fd
--- /dev/null
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs
@@ -0,0 +1,29 @@
+{{#if (Property.QueryIsEnumerable property)}}
+    {{#if (Property.QueryIsBool property)}}
+        if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
+        {
+            xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", string.Join(" ", poco.{{Property.WritePropertyName property}}));
+        }
+    {{else}}
+        if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
+        {
+            xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", string.Join(" ", poco.{{Property.WritePropertyName property}}));
+        }
+    {{/if}}
+{{else}}
+    {{#if (Property.QueryIsBool property)}}
+        if(poco.{{Property.WritePropertyName property}})
+        {
+            xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", "true");
+        }
+    {{else if (Property.QueryIsEnum property)}}
+        xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}}.ToString());
+    {{else if (Property.QueryIsNumeric property)}}
+        xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}}.ToString(CultureInfo.InvariantCulture));
+    {{else}}
+        if(!string.IsNullOrWhiteSpace(poco.{{Property.WritePropertyName property}}))
+        {
+            xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}});
+        }
+    {{/if}}
+{{/if}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-facade-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-facade-template.hbs
index d216e82a8..99097cf76 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-facade-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-facade-template.hbs
@@ -44,38 +44,38 @@ namespace SysML2.NET.Serializer.Xmi.Readers
         /// A dictionary that contains functions that return <see cref="IData"/> based a key that represents the xsi Type
         /// and a provided <see cref="IXmiDataCache"/>, <see cref="IExternalReferenceService" />, <see cref="ILoggerFactory"/> and <see cref="XmlReader"/>
         /// </summary>
-        private readonly Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IData>> readerCache;
+        private readonly Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IXmiElementOriginMap, IData>> readerCache;
 
         /// <summary>
         /// A dictionary that contains functions that return an awaitable <see cref="Task" /> with the <see cref="IData"/> based a key that represents the xsi Type
         /// and a provided <see cref="IXmiDataCache"/>, <see cref="IExternalReferenceService" />, <see cref="ILoggerFactory"/> and <see cref="XmlReader"/>
         /// </summary>
-        private readonly Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, Task<IData>>> readerAsyncCache;
+        private readonly Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IXmiElementOriginMap, Task<IData>>> readerAsyncCache;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="XmiDataReaderFacade"/>
         /// </summary>
         public XmiDataReaderFacade()
         {
-            this.readerCache = new Dictionary<string, Func<IXmiDataCache, IExternalReferenceService,ILoggerFactory, XmlReader, Uri, IData>>
+            this.readerCache = new Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IXmiElementOriginMap, IData>>
             {
             {{ #each this as | class | }}
-                ["sysml:{{ class.Name }}"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:{{ class.Name }}"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var {{ String.LowerCaseFirstLetter class.Name }}Reader = new {{ class.Name }}Reader(cache, this, externalReferenceService, loggerFactory);
+                    var {{ String.LowerCaseFirstLetter class.Name }}Reader = new {{ class.Name }}Reader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return {{ String.LowerCaseFirstLetter class.Name }}Reader.Read(subXmlReader, currentLocation);
                 },
             {{/each}}
             };
 
-            this.readerAsyncCache = new Dictionary<string, Func<IXmiDataCache, IExternalReferenceService,ILoggerFactory, XmlReader, Uri, Task<IData>>>
+            this.readerAsyncCache = new Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IXmiElementOriginMap, Task<IData>>>
             {
                 {{ #each this as | class | }}
-                    ["sysml:{{ class.Name }}"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                    ["sysml:{{ class.Name }}"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                     {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var {{ String.LowerCaseFirstLetter class.Name }}Reader = new {{ class.Name }}Reader(cache, this, externalReferenceService, loggerFactory);
+                    var {{ String.LowerCaseFirstLetter class.Name }}Reader = new {{ class.Name }}Reader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await {{ String.LowerCaseFirstLetter class.Name }}Reader.ReadAsync(subXmlReader, currentLocation);
                     },
                 {{/each}}
@@ -95,7 +95,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
         /// <param name="explicitTypeName">The explicit type name to resolve, in case of un-specified xsi:type</param>
         /// <returns>An instance of the read <see cref="IData"/></returns>
         /// <exception cref="InvalidOperationException">If the xsi:type is not supported</exception>
-        public IData QueryXmiData(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "")
+        public IData QueryXmiData(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "", IXmiElementOriginMap elementOriginMap = null)
         {
             AssertValidQueryXmiDataParameters(xmiReader, xmiDataCache, currentLocation);
 
@@ -107,12 +107,12 @@ namespace SysML2.NET.Serializer.Xmi.Readers
             }
 
             xsiType ??= explicitTypeName;
-            
+
             if (this.readerCache.TryGetValue(xsiType, out var readerFactory))
             {
-                return readerFactory(xmiDataCache, externalReferenceService, loggerFactory, xmiReader, currentLocation);
+                return readerFactory(xmiDataCache, externalReferenceService, loggerFactory, xmiReader, currentLocation, elementOriginMap);
             }
-            
+
             throw new InvalidOperationException($"No reader found for xsi:type - {xsiType}");
         }
 
@@ -129,24 +129,24 @@ namespace SysML2.NET.Serializer.Xmi.Readers
         /// <param name="explicitTypeName">The explicit type name to resolve, in case of un-specified xsi:type</param>
         /// <returns>An awaitable <see cref="Task" /> with the instance of the read <see cref="IData"/></returns>
         /// <exception cref="InvalidOperationException">If the xsi:type is not supported</exception>
-        public Task<IData> QueryXmiDataAsync(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "")
+        public Task<IData> QueryXmiDataAsync(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "", IXmiElementOriginMap elementOriginMap = null)
         {
             AssertValidQueryXmiDataParameters(xmiReader, xmiDataCache, currentLocation);
-        
+
             var xsiType = xmiReader.GetAttribute("xsi:type");
-        
+
             if (xsiType == null && string.IsNullOrEmpty(explicitTypeName))
             {
                 throw new InvalidOperationException($"The xsi:type is not specified");
             }
-    
+
             xsiType ??= explicitTypeName;
-        
+
             if (this.readerAsyncCache.TryGetValue(xsiType, out var readerFactory))
             {
-                return readerFactory(xmiDataCache, externalReferenceService, loggerFactory, xmiReader, currentLocation);
+                return readerFactory(xmiDataCache, externalReferenceService, loggerFactory, xmiReader, currentLocation, elementOriginMap);
             }
-        
+
             throw new InvalidOperationException($"No reader found for xsi:type - {xsiType}");
         }
 
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs
index 6105b3556..71dbbd576 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs
@@ -61,7 +61,8 @@ namespace SysML2.NET.Serializer.Xmi.Readers
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public {{this.Name}}Reader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public {{this.Name}}Reader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<{{this.Name}}Reader>.Instance : loggerFactory.CreateLogger<{{this.Name}}Reader>();
         }
@@ -107,6 +108,8 @@ namespace SysML2.NET.Serializer.Xmi.Readers
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "{{this.Name}}", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 {{#with this as |class| }}
                     {{ #each (Class.QueryAllProperties this) as | property | }}
                         {{#unless this.IsTransient}}
@@ -187,6 +190,8 @@ namespace SysML2.NET.Serializer.Xmi.Readers
                 {
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "{{this.Name}}", poco.Id);
                 }
+
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
         
                     {{#with this as |class| }}
                         {{ #each (Class.QueryAllProperties this) as | property | }}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
new file mode 100644
index 000000000..74dea0f05
--- /dev/null
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
@@ -0,0 +1,115 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="{{this.Name}}Writer.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    {{ #Class.WriteEnumerationNameSpaces this}}
+    {{ #Class.WriteNameSpaces this POCO}}
+    using SysML2.NET.Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace this }};
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="{{this.Name}}Writer" /> is to write an instance of <see cref="I{{this.Name}}" />
+    /// to the XMI document
+    /// </summary>
+    public static class {{this.Name}}Writer
+    {
+        /// <summary>
+        /// Writes the <see cref="I{{this.Name}}" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="I{{this.Name}}" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriter">The <see cref="IXmiWriter" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, I{{this.Name}} poco, string elementName, bool includeDerivedProperties, IXmiWriter xmiWriter, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:{{this.Name}}");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            {{#with this as |class| }}
+                {{ #each (Class.QueryAllProperties this) as | property | }}
+                    {{#unless this.IsTransient}}
+                        {{#unless this.IsDerived}}
+                            {{#unless (Property.QueryIsReferenceProperty this)}}
+                                {{#unless (Property.IsPropertyRedefinedInClass this class)}}
+                                    {{> core-xmi-writer-partial-for-attribute-template this}}
+                                {{/unless}}
+                            {{/unless}}
+                        {{/unless}}
+                    {{/unless}}
+                {{/each}}
+            {{/with}}
+
+            // Derived scalar properties
+            if(includeDerivedProperties)
+            {
+                {{#with this as |class| }}
+                    {{ #each (Class.QueryAllProperties this) as | property | }}
+                        {{#unless this.IsTransient}}
+                            {{#if this.IsDerived}}
+                                {{#unless (Property.QueryIsReferenceProperty this)}}
+                                    {{#unless (Property.IsPropertyRedefinedInClass this class)}}
+                                        {{> core-xmi-writer-partial-for-attribute-template this}}
+                                    {{/unless}}
+                                {{/unless}}
+                            {{/if}}
+                        {{/unless}}
+                    {{/each}}
+                {{/with}}
+            }
+
+            // Reference/containment properties as child elements
+            {{#with this as |class| }}
+                {{ #each (Class.QueryAllProperties this) as | property | }}
+                    {{#unless this.IsTransient}}
+                        {{#unless this.IsDerived}}
+                            {{#if (Property.QueryIsReferenceProperty this)}}
+                                {{#unless (Property.IsPropertyRedefinedInClass this class)}}
+                                    // {{Property.WritePropertyName this}} child elements handled by reflection-based XmiWriter
+                                {{/unless}}
+                            {{/if}}
+                        {{/unless}}
+                    {{/unless}}
+                {{/each}}
+            {{/with}}
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
new file mode 100644
index 000000000..8a78d1959
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
@@ -0,0 +1,154 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RoundTripTestFixture.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Tests
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+
+    using Core.POCO.Root.Namespaces;
+
+    using Microsoft.Extensions.DependencyInjection;
+    using Microsoft.Extensions.Logging;
+
+    using SysML2.NET.Serializer.Xmi.Extensions;
+    using SysML2.NET.Serializer.Xmi.Readers;
+
+    [TestFixture]
+    public class RoundTripTestFixture
+    {
+        private ILoggerFactory loggerFactory;
+
+        [SetUp]
+        public void Setup()
+        {
+            var serviceProvider = new ServiceCollection()
+                .AddLogging(x => x.AddConsole())
+                .BuildServiceProvider();
+
+            this.loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
+        }
+
+        [Test]
+        public void Verify_that_deserialization_with_origin_map_tracks_elements()
+        {
+            var xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
+            var deSerializer = new DeSerializer(
+                new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
+                new XmiDataReaderFacade(),
+                xmiDataCache,
+                this.loggerFactory);
+
+            var originMap = new XmiElementOriginMap();
+
+            var filePath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "Domain Libraries", "Quantities and Units", "Quantities.sysmlx");
+            var fileUri = new Uri(filePath);
+
+            var rootNamespace = deSerializer.DeSerialize(fileUri, originMap);
+
+            Assert.That(rootNamespace, Is.Not.Null);
+
+            // Verify that elements were tracked
+            var allSourceFiles = originMap.GetAllSourceFiles().ToList();
+            Assert.That(allSourceFiles, Is.Not.Empty);
+
+            // Verify that the root namespace was registered
+            var rootNsId = originMap.GetRootNamespaceId(fileUri);
+            Assert.That(rootNsId, Is.EqualTo(rootNamespace.Id));
+
+            // Verify that elements in the file can be queried
+            var elementsInFile = originMap.GetElementsInFile(fileUri).ToList();
+            Assert.That(elementsInFile, Is.Not.Empty);
+            Assert.That(elementsInFile, Does.Contain(rootNamespace.Id));
+        }
+
+        [Test]
+        public void Verify_that_serialized_output_is_well_formed_xml_with_correct_root()
+        {
+            // Step 1: Deserialize original
+            var xmiDataCache1 = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
+            var deSerializer1 = new DeSerializer(
+                new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
+                new XmiDataReaderFacade(),
+                xmiDataCache1,
+                this.loggerFactory);
+
+            var filePath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "Domain Libraries", "Quantities and Units", "Quantities.sysmlx");
+            var originalNamespace = deSerializer1.DeSerialize(new Uri(filePath));
+
+            Assert.That(originalNamespace, Is.Not.Null);
+
+            // Step 2: Serialize to stream
+            var serializer = new Serializer(this.loggerFactory);
+            var memoryStream = new MemoryStream();
+
+            serializer.Serialize(originalNamespace, false, memoryStream);
+
+            Assert.That(memoryStream.Length, Is.GreaterThan(0));
+
+            // Step 3: Verify the output is well-formed XML with correct structure
+            memoryStream.Seek(0, SeekOrigin.Begin);
+
+            var xmlDoc = new System.Xml.XmlDocument();
+            Assert.That(() => xmlDoc.Load(memoryStream), Throws.Nothing, "Output should be well-formed XML");
+
+            var rootElement = xmlDoc.DocumentElement;
+            Assert.That(rootElement, Is.Not.Null);
+            Assert.That(rootElement.LocalName, Is.EqualTo("Namespace"));
+            Assert.That(rootElement.GetAttribute("id", "http://www.omg.org/spec/XMI/20131001"), Is.EqualTo(originalNamespace.Id.ToString()));
+
+            // Verify there are child elements (ownedRelationship)
+            var childElements = rootElement.ChildNodes.Cast<System.Xml.XmlNode>().Where(n => n.NodeType == System.Xml.XmlNodeType.Element).ToList();
+            Assert.That(childElements, Is.Not.Empty, "Should have child elements");
+        }
+
+        [Test]
+        public void Verify_that_origin_map_captures_multi_file_references()
+        {
+            var xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
+            var deSerializer = new DeSerializer(
+                new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
+                new XmiDataReaderFacade(),
+                xmiDataCache,
+                this.loggerFactory);
+
+            var originMap = new XmiElementOriginMap();
+
+            // Quantities.sysmlx references other files like ScalarValues.kermlx, ISQBase.sysmlx, etc.
+            var filePath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "Domain Libraries", "Quantities and Units", "Quantities.sysmlx");
+            var fileUri = new Uri(filePath);
+
+            deSerializer.DeSerialize(fileUri, originMap);
+
+            var allSourceFiles = originMap.GetAllSourceFiles().ToList();
+
+            // Should have multiple source files since Quantities.sysmlx has external references
+            Assert.That(allSourceFiles.Count, Is.GreaterThan(1));
+
+            // Each source file should have a root namespace registered
+            foreach (var sourceFile in allSourceFiles)
+            {
+                var rootNsId = originMap.GetRootNamespaceId(sourceFile);
+                Assert.That(rootNsId, Is.Not.EqualTo(Guid.Empty), $"Root namespace not registered for {sourceFile}");
+            }
+        }
+    }
+}
diff --git a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
index fb5951346..e4756b9fb 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
@@ -1,20 +1,20 @@
-// -------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 // <copyright file="SerializerTestFixture.cs" company="Starion Group S.A.">
-// 
+//
 //   Copyright 2022-2026 Starion Group S.A.
-// 
+//
 //   Licensed under the Apache License, Version 2.0 (the "License");
 //   you may not use this file except in compliance with the License.
 //   You may obtain a copy of the License at
-// 
+//
 //        http://www.apache.org/licenses/LICENSE-2.0
-// 
+//
 //    Unless required by applicable law or agreed to in writing, software
 //    distributed under the License is distributed on an "AS IS" BASIS,
 //    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
-// 
+//
 // </copyright>
 // ------------------------------------------------------------------------------------------------
 
@@ -24,20 +24,22 @@ namespace SysML2.NET.Serializer.Xmi.Tests
     using System.IO;
     using System.Threading;
     using System.Threading.Tasks;
+
     using Core.POCO.Root.Namespaces;
+
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.Logging;
 
     using SysML2.NET.Serializer.Xmi.Extensions;
     using SysML2.NET.Serializer.Xmi.Readers;
-    
+
     [TestFixture]
     public class SerializerTestFixture
     {
         private Serializer serializer;
         private DeSerializer deSerializer;
         private XmiDataCache xmiDataCache;
-        
+
         private INamespace anonymouseNameSpace;
 
         [SetUp]
@@ -47,12 +49,12 @@ public void Setup()
                 .AddLogging(x => x.AddConsole())
                 .BuildServiceProvider();
 
-            this.xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(),serviceProvider.GetRequiredService<ILogger<XmiDataCache>>());
+            this.xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), serviceProvider.GetRequiredService<ILogger<XmiDataCache>>());
 
             this.deSerializer = new DeSerializer(new ExternalReferenceService(serviceProvider.GetRequiredService<ILogger<ExternalReferenceService>>()), new XmiDataReaderFacade(), this.xmiDataCache, serviceProvider.GetRequiredService<ILoggerFactory>());
 
             this.ReadAndAssemblePopulationFromXmiFile();
-            
+
             this.serializer = new Serializer(serviceProvider.GetRequiredService<ILoggerFactory>());
         }
 
@@ -60,9 +62,37 @@ public void Setup()
         public void Verify_that_the_name_space_can_be_serialized_to_xmi()
         {
             var targetStream = new MemoryStream();
-            
-            Assert.That(() => this.serializer.Serialize(this.anonymouseNameSpace, false,targetStream), Throws.Nothing);
-            
+
+            Assert.That(() => this.serializer.Serialize(this.anonymouseNameSpace, false, targetStream), Throws.Nothing);
+
+            Assert.That(targetStream.Length, Is.GreaterThan(0));
+        }
+
+        [Test]
+        public void Verify_that_serialized_xmi_contains_expected_structure()
+        {
+            var targetStream = new MemoryStream();
+
+            this.serializer.Serialize(this.anonymouseNameSpace, false, targetStream);
+
+            targetStream.Seek(0, SeekOrigin.Begin);
+            var reader = new StreamReader(targetStream);
+            var content = reader.ReadToEnd();
+
+            Assert.That(content, Does.Contain("sysml:Namespace"));
+            Assert.That(content, Does.Contain("xmi:id="));
+            Assert.That(content, Does.Contain("xmlns:xmi"));
+            Assert.That(content, Does.Contain("xmlns:xsi"));
+        }
+
+        [Test]
+        public async Task Verify_that_the_name_space_can_be_serialized_to_xmi_async()
+        {
+            var targetStream = new MemoryStream();
+
+            await this.serializer.SerializeAsync(this.anonymouseNameSpace, false, targetStream, CancellationToken.None);
+
+            Assert.That(targetStream.Length, Is.GreaterThan(0));
         }
 
         private void ReadAndAssemblePopulationFromXmiFile()
diff --git a/SysML2.NET.Serializer.Xmi.Tests/XmiElementOriginMapTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/XmiElementOriginMapTestFixture.cs
new file mode 100644
index 000000000..c56691569
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi.Tests/XmiElementOriginMapTestFixture.cs
@@ -0,0 +1,126 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="XmiElementOriginMapTestFixture.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Tests
+{
+    using System;
+    using System.Linq;
+
+    [TestFixture]
+    public class XmiElementOriginMapTestFixture
+    {
+        private XmiElementOriginMap originMap;
+
+        [SetUp]
+        public void Setup()
+        {
+            this.originMap = new XmiElementOriginMap();
+        }
+
+        [Test]
+        public void Verify_that_element_can_be_registered_and_retrieved()
+        {
+            var elementId = Guid.NewGuid();
+            var sourceFile = new Uri("file:///C:/test/model.sysmlx");
+
+            this.originMap.Register(elementId, sourceFile);
+
+            Assert.That(this.originMap.GetSourceFile(elementId), Is.EqualTo(sourceFile));
+        }
+
+        [Test]
+        public void Verify_that_GetSourceFile_returns_null_for_unregistered_element()
+        {
+            var elementId = Guid.NewGuid();
+
+            Assert.That(this.originMap.GetSourceFile(elementId), Is.Null);
+        }
+
+        [Test]
+        public void Verify_that_GetElementsInFile_returns_correct_elements()
+        {
+            var sourceFile = new Uri("file:///C:/test/model.sysmlx");
+            var element1 = Guid.NewGuid();
+            var element2 = Guid.NewGuid();
+            var element3 = Guid.NewGuid();
+            var otherFile = new Uri("file:///C:/test/other.sysmlx");
+
+            this.originMap.Register(element1, sourceFile);
+            this.originMap.Register(element2, sourceFile);
+            this.originMap.Register(element3, otherFile);
+
+            var elementsInFile = this.originMap.GetElementsInFile(sourceFile).ToList();
+
+            Assert.That(elementsInFile, Has.Count.EqualTo(2));
+            Assert.That(elementsInFile, Does.Contain(element1));
+            Assert.That(elementsInFile, Does.Contain(element2));
+            Assert.That(elementsInFile, Does.Not.Contain(element3));
+        }
+
+        [Test]
+        public void Verify_that_GetAllSourceFiles_returns_distinct_files()
+        {
+            var file1 = new Uri("file:///C:/test/model1.sysmlx");
+            var file2 = new Uri("file:///C:/test/model2.sysmlx");
+
+            this.originMap.Register(Guid.NewGuid(), file1);
+            this.originMap.Register(Guid.NewGuid(), file1);
+            this.originMap.Register(Guid.NewGuid(), file2);
+
+            var allFiles = this.originMap.GetAllSourceFiles().ToList();
+
+            Assert.That(allFiles, Has.Count.EqualTo(2));
+            Assert.That(allFiles, Does.Contain(file1));
+            Assert.That(allFiles, Does.Contain(file2));
+        }
+
+        [Test]
+        public void Verify_that_root_namespace_can_be_registered_and_retrieved()
+        {
+            var sourceFile = new Uri("file:///C:/test/model.sysmlx");
+            var rootNamespaceId = Guid.NewGuid();
+
+            this.originMap.RegisterRootNamespace(sourceFile, rootNamespaceId);
+
+            Assert.That(this.originMap.GetRootNamespaceId(sourceFile), Is.EqualTo(rootNamespaceId));
+        }
+
+        [Test]
+        public void Verify_that_GetRootNamespaceId_returns_empty_guid_for_unregistered_file()
+        {
+            var sourceFile = new Uri("file:///C:/test/model.sysmlx");
+
+            Assert.That(this.originMap.GetRootNamespaceId(sourceFile), Is.EqualTo(Guid.Empty));
+        }
+
+        [Test]
+        public void Verify_that_registering_same_element_overwrites_source_file()
+        {
+            var elementId = Guid.NewGuid();
+            var file1 = new Uri("file:///C:/test/model1.sysmlx");
+            var file2 = new Uri("file:///C:/test/model2.sysmlx");
+
+            this.originMap.Register(elementId, file1);
+            this.originMap.Register(elementId, file2);
+
+            Assert.That(this.originMap.GetSourceFile(elementId), Is.EqualTo(file2));
+        }
+    }
+}
diff --git a/SysML2.NET.Serializer.Xmi/DeSerializer.cs b/SysML2.NET.Serializer.Xmi/DeSerializer.cs
index b97c584ed..1b6002e0f 100644
--- a/SysML2.NET.Serializer.Xmi/DeSerializer.cs
+++ b/SysML2.NET.Serializer.Xmi/DeSerializer.cs
@@ -1,20 +1,20 @@
-// -------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 // <copyright file="DeSerializer.cs" company="Starion Group S.A.">
-// 
+//
 //   Copyright 2022-2026 Starion Group S.A.
-// 
+//
 //   Licensed under the Apache License, Version 2.0 (the "License");
 //   you may not use this file except in compliance with the License.
 //   You may obtain a copy of the License at
-// 
+//
 //        http://www.apache.org/licenses/LICENSE-2.0
-// 
+//
 //    Unless required by applicable law or agreed to in writing, software
 //    distributed under the License is distributed on an "AS IS" BASIS,
 //    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
-// 
+//
 // </copyright>
 // ------------------------------------------------------------------------------------------------
 
@@ -66,6 +66,11 @@ public class DeSerializer : IDeSerializer
         /// </summary>
         private readonly IXmiDataReaderFacade xmiDataReaderFacade;
 
+        /// <summary>
+        /// The optional <see cref="IXmiElementOriginMap" /> used to track element-to-file associations during deserialization
+        /// </summary>
+        private IXmiElementOriginMap elementOriginMap;
+
         /// <summary>Initializes a new instance of the <see cref="DeSerializer"></see> class.</summary>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService" /> providing external reference file resolve</param>
         /// <param name="xmiDataReaderFacade">
@@ -99,6 +104,31 @@ public INamespace DeSerialize(Uri fileLocation)
             return this.DeSerialize(fileLocation, true);
         }
 
+        /// <summary>
+        /// Deserializes the XMI file to a read <see cref="INamespace" />, tracking element origins
+        /// </summary>
+        /// <param name="fileLocation">
+        /// the <see cref="Uri" /> that locates the XMI file
+        /// </param>
+        /// <param name="elementOriginMap">
+        /// The <see cref="IXmiElementOriginMap" /> to populate with element-to-file associations
+        /// </param>
+        /// <exception cref="ArgumentNullException">If the <see cref="Uri" /> or <see cref="IXmiElementOriginMap" /> is null</exception>
+        /// <exception cref="FileNotFoundException">If the <see cref="Uri" /> does not locate an existing file</exception>
+        /// <returns>
+        /// The read <see cref="INamespace" />
+        /// </returns>
+        public INamespace DeSerialize(Uri fileLocation, IXmiElementOriginMap elementOriginMap)
+        {
+            if (elementOriginMap == null)
+            {
+                throw new ArgumentNullException(nameof(elementOriginMap));
+            }
+
+            this.elementOriginMap = elementOriginMap;
+            return this.DeSerialize(fileLocation, true);
+        }
+
         /// <summary>
         /// Deserializes asynchronously the XMI file to a read <see cref="INamespace" />
         /// </summary>
@@ -116,6 +146,32 @@ public Task<INamespace> DeSerializeAsync(Uri fileLocation, CancellationToken can
             return this.DeSerializeAsync(fileLocation, true, cancellationToken);
         }
 
+        /// <summary>
+        /// Deserializes asynchronously the XMI file to a read <see cref="INamespace" />, tracking element origins
+        /// </summary>
+        /// <param name="fileLocation">
+        /// the <see cref="Uri" /> that locates the XMI file
+        /// </param>
+        /// <param name="elementOriginMap">
+        /// The <see cref="IXmiElementOriginMap" /> to populate with element-to-file associations
+        /// </param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken" /> to cancel the read process</param>
+        /// <exception cref="ArgumentNullException">If the <see cref="Uri" /> or <see cref="IXmiElementOriginMap" /> is null</exception>
+        /// <exception cref="FileNotFoundException">If the <see cref="Uri" /> does not locate an existing file</exception>
+        /// <returns>
+        /// An awaitable <see cref="Task{TResult}" /> with the read <see cref="INamespace" />
+        /// </returns>
+        public Task<INamespace> DeSerializeAsync(Uri fileLocation, IXmiElementOriginMap elementOriginMap, CancellationToken cancellationToken = default)
+        {
+            if (elementOriginMap == null)
+            {
+                throw new ArgumentNullException(nameof(elementOriginMap));
+            }
+
+            this.elementOriginMap = elementOriginMap;
+            return this.DeSerializeAsync(fileLocation, true, cancellationToken);
+        }
+
         /// <summary>
         /// Deserializes asynchronously the XMI file to a read <see cref="INamespace" />
         /// </summary>
@@ -195,7 +251,10 @@ private async Task<INamespace> ReadAsync(Stream stream, Uri fileLocation, bool i
                 return existingNamespace;
             }
 
-            var readNamespace = (INamespace)await this.xmiDataReaderFacade.QueryXmiDataAsync(xmlReader, this.cache, fileLocation, this.externalReferenceService, this.loggerFactory, xmlReader.Name);
+            var readNamespace = (INamespace)await this.xmiDataReaderFacade.QueryXmiDataAsync(xmlReader, this.cache, fileLocation, this.externalReferenceService, this.loggerFactory, xmlReader.Name, this.elementOriginMap);
+
+            this.elementOriginMap?.RegisterRootNamespace(fileLocation, readNamespace.Id);
+
             stopWatch.Stop();
             this.logger.LogTrace("finished to read xml {DocumentName} in {ElapsedMilliseconds}[ms]", fileInfo.Name, stopWatch.ElapsedMilliseconds);
 
@@ -274,7 +333,10 @@ private INamespace Read(Stream stream, Uri fileLocation, bool isRoot)
                 return existingNamespace;
             }
 
-            var readNamespace = (INamespace)this.xmiDataReaderFacade.QueryXmiData(xmlReader, this.cache, fileLocation, this.externalReferenceService, this.loggerFactory, xmlReader.Name);
+            var readNamespace = (INamespace)this.xmiDataReaderFacade.QueryXmiData(xmlReader, this.cache, fileLocation, this.externalReferenceService, this.loggerFactory, xmlReader.Name, this.elementOriginMap);
+
+            this.elementOriginMap?.RegisterRootNamespace(fileLocation, readNamespace.Id);
+
             stopWatch.Stop();
             this.logger.LogTrace("finished to read xml {DocumentName} in {ElapsedMilliseconds}[ms]", fileInfo.Name, stopWatch.ElapsedMilliseconds);
 
diff --git a/SysML2.NET.Serializer.Xmi/IDeSerializer.cs b/SysML2.NET.Serializer.Xmi/IDeSerializer.cs
index b586a02c6..b8e6a5a3e 100644
--- a/SysML2.NET.Serializer.Xmi/IDeSerializer.cs
+++ b/SysML2.NET.Serializer.Xmi/IDeSerializer.cs
@@ -48,6 +48,22 @@ public interface IDeSerializer
         /// </returns>
         INamespace DeSerialize(Uri fileLocation);
 
+        /// <summary>
+        /// Deserializes the XMI file to a read <see cref="INamespace"/>, tracking element origins
+        /// </summary>
+        /// <param name="fileLocation">
+        /// the <see cref="Uri"/> that locates the XMI file
+        /// </param>
+        /// <param name="elementOriginMap">
+        /// The <see cref="IXmiElementOriginMap"/> to populate with element-to-file associations
+        /// </param>
+        /// <exception cref="ArgumentNullException">If the <see cref="Uri"/> or <see cref="IXmiElementOriginMap"/> is null</exception>
+        /// <exception cref="FileNotFoundException">If the <see cref="Uri"/> does not locate an existing file</exception>
+        /// <returns>
+        /// The read <see cref="INamespace"/>
+        /// </returns>
+        INamespace DeSerialize(Uri fileLocation, IXmiElementOriginMap elementOriginMap);
+
         /// <summary>
         /// Deserializes asynchronously the XMI file to a read <see cref="INamespace"/>
         /// </summary>
@@ -61,5 +77,22 @@ public interface IDeSerializer
         /// An awaitable <see cref="Task{TResult}"/> with the read <see cref="INamespace"/>
         /// </returns>
         Task<INamespace> DeSerializeAsync(Uri fileLocation, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Deserializes asynchronously the XMI file to a read <see cref="INamespace"/>, tracking element origins
+        /// </summary>
+        /// <param name="fileLocation">
+        /// the <see cref="Uri"/> that locates the XMI file
+        /// </param>
+        /// <param name="elementOriginMap">
+        /// The <see cref="IXmiElementOriginMap"/> to populate with element-to-file associations
+        /// </param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> to cancel the read process</param>
+        /// <exception cref="ArgumentNullException">If the <see cref="Uri"/> or <see cref="IXmiElementOriginMap"/> is null</exception>
+        /// <exception cref="FileNotFoundException">If the <see cref="Uri"/> does not locate an existing file</exception>
+        /// <returns>
+        /// An awaitable <see cref="Task{TResult}"/> with the read <see cref="INamespace"/>
+        /// </returns>
+        Task<INamespace> DeSerializeAsync(Uri fileLocation, IXmiElementOriginMap elementOriginMap, CancellationToken cancellationToken = default);
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/ISerializer.cs b/SysML2.NET.Serializer.Xmi/ISerializer.cs
index b80194b7e..263b17a30 100644
--- a/SysML2.NET.Serializer.Xmi/ISerializer.cs
+++ b/SysML2.NET.Serializer.Xmi/ISerializer.cs
@@ -1,25 +1,26 @@
 // -------------------------------------------------------------------------------------------------
 // <copyright file="ISerializer.cs" company="Starion Group S.A.">
-// 
+//
 //   Copyright 2022-2026 Starion Group S.A.
-// 
+//
 //   Licensed under the Apache License, Version 2.0 (the "License");
 //   you may not use this file except in compliance with the License.
 //   You may obtain a copy of the License at
-// 
+//
 //        http://www.apache.org/licenses/LICENSE-2.0
-// 
+//
 //    Unless required by applicable law or agreed to in writing, software
 //    distributed under the License is distributed on an "AS IS" BASIS,
 //    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
-// 
+//
 // </copyright>
 // ------------------------------------------------------------------------------------------------
 
 namespace SysML2.NET.Serializer.Xmi
 {
+    using System;
     using System.Collections.Generic;
     using System.IO;
     using System.Threading;
@@ -48,6 +49,27 @@ public interface ISerializer
         /// </param>
         void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream);
 
+        /// <summary>
+        /// Serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>,
+        /// using an origin map for href reconstruction
+        /// </summary>
+        /// <param name="namespace">
+        /// The <see cref="INamespace"/> that shall be serialized
+        /// </param>
+        /// <param name="includeDerivedProperties">
+        /// Asserts that derived properties should also be part of the serialization
+        /// </param>
+        /// <param name="stream">
+        /// The target <see cref="Stream"/>
+        /// </param>
+        /// <param name="elementOriginMap">
+        /// The optional <see cref="IXmiElementOriginMap"/> for href reconstruction
+        /// </param>
+        /// <param name="currentFileUri">
+        /// The optional <see cref="Uri"/> of the current output file for relative href computation
+        /// </param>
+        void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+
         /// <summary>
         /// Asynchronously serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>
         /// </summary>
@@ -64,5 +86,14 @@ public interface ISerializer
         /// The <see cref="CancellationToken"/> used to cancel the operation
         /// </param>
         Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, Stream stream, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Serialize an <see cref="INamespace"/> to multiple XMI files based on the element origin map
+        /// </summary>
+        /// <param name="rootNamespace">The root <see cref="INamespace"/> containing all elements</param>
+        /// <param name="elementOriginMap">The <see cref="IXmiElementOriginMap"/> tracking element-to-file associations</param>
+        /// <param name="outputDirectory">The target directory for output files</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOriginMap, DirectoryInfo outputDirectory, bool includeDerivedProperties);
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/IXmiElementOriginMap.cs b/SysML2.NET.Serializer.Xmi/IXmiElementOriginMap.cs
new file mode 100644
index 000000000..343f1192f
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/IXmiElementOriginMap.cs
@@ -0,0 +1,73 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IXmiElementOriginMap.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Tracks the association between elements and the XMI source files they were deserialized from.
+    /// This enables faithful round-trip serialization back to multiple XMI files with correct href references.
+    /// </summary>
+    public interface IXmiElementOriginMap
+    {
+        /// <summary>
+        /// Registers the source file for a given element
+        /// </summary>
+        /// <param name="elementId">The <see cref="Guid"/> identifier of the element</param>
+        /// <param name="sourceFile">The <see cref="Uri"/> of the source XMI file</param>
+        void Register(Guid elementId, Uri sourceFile);
+
+        /// <summary>
+        /// Gets the source file for a given element
+        /// </summary>
+        /// <param name="elementId">The <see cref="Guid"/> identifier of the element</param>
+        /// <returns>The <see cref="Uri"/> of the source file, or null if not tracked</returns>
+        Uri GetSourceFile(Guid elementId);
+
+        /// <summary>
+        /// Gets all element identifiers that were deserialized from the given source file
+        /// </summary>
+        /// <param name="sourceFile">The <see cref="Uri"/> of the source XMI file</param>
+        /// <returns>An <see cref="IEnumerable{Guid}"/> of element identifiers</returns>
+        IEnumerable<Guid> GetElementsInFile(Uri sourceFile);
+
+        /// <summary>
+        /// Gets all source files that have been registered
+        /// </summary>
+        /// <returns>An <see cref="IEnumerable{Uri}"/> of source file URIs</returns>
+        IEnumerable<Uri> GetAllSourceFiles();
+
+        /// <summary>
+        /// Registers the root namespace identifier for a given source file
+        /// </summary>
+        /// <param name="sourceFile">The <see cref="Uri"/> of the source XMI file</param>
+        /// <param name="rootNamespaceId">The <see cref="Guid"/> of the root namespace element</param>
+        void RegisterRootNamespace(Uri sourceFile, Guid rootNamespaceId);
+
+        /// <summary>
+        /// Gets the root namespace identifier for a given source file
+        /// </summary>
+        /// <param name="sourceFile">The <see cref="Uri"/> of the source XMI file</param>
+        /// <returns>The <see cref="Guid"/> of the root namespace, or <see cref="Guid.Empty"/> if not registered</returns>
+        Guid GetRootNamespaceId(Uri sourceFile);
+    }
+}
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs
index 3511bd613..83f09fbd9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs
@@ -90,7 +90,7 @@ public class AcceptActionUsageReader : XmiDataReader<IAcceptActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AcceptActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AcceptActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AcceptActionUsageReader>.Instance : loggerFactory.CreateLogger<AcceptActionUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AcceptActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AcceptActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs
index 75d1da08a..72d9c0043 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs
@@ -86,7 +86,7 @@ public class ActionDefinitionReader : XmiDataReader<IActionDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ActionDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ActionDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ActionDefinitionReader>.Instance : loggerFactory.CreateLogger<ActionDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ActionDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -370,7 +372,7 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -391,7 +393,7 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -448,6 +450,8 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ActionDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -686,7 +690,7 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -707,7 +711,7 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs
index 53a7ddbdf..9bedda4eb 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs
@@ -89,7 +89,7 @@ public class ActionUsageReader : XmiDataReader<IActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ActionUsageReader>.Instance : loggerFactory.CreateLogger<ActionUsageReader>();
         }
@@ -135,6 +135,8 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -559,7 +561,7 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -580,7 +582,7 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -649,6 +651,8 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1073,7 +1077,7 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1094,7 +1098,7 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs
index cf1a0377c..8acdcf921 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs
@@ -66,7 +66,7 @@ public class ActorMembershipReader : XmiDataReader<IActorMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ActorMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ActorMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ActorMembershipReader>.Instance : loggerFactory.CreateLogger<ActorMembershipReader>();
         }
@@ -112,6 +112,8 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ActorMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -324,7 +326,7 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -345,7 +347,7 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -366,7 +368,7 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -387,7 +389,7 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -456,6 +458,8 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ActorMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -668,7 +672,7 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -689,7 +693,7 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -710,7 +714,7 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -731,7 +735,7 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs
index 62bbacb6e..7f363dc55 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs
@@ -86,7 +86,7 @@ public class AllocationDefinitionReader : XmiDataReader<IAllocationDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AllocationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AllocationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AllocationDefinitionReader>.Instance : loggerFactory.CreateLogger<AllocationDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AllocationDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -422,7 +424,7 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -443,7 +445,7 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -464,7 +466,7 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -485,7 +487,7 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -542,6 +544,8 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AllocationDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -832,7 +836,7 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -853,7 +857,7 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -874,7 +878,7 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -895,7 +899,7 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs
index 6f239134b..98d9aa3bb 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs
@@ -91,7 +91,7 @@ public class AllocationUsageReader : XmiDataReader<IAllocationUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AllocationUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AllocationUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AllocationUsageReader>.Instance : loggerFactory.CreateLogger<AllocationUsageReader>();
         }
@@ -137,6 +137,8 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AllocationUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -613,7 +615,7 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -634,7 +636,7 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -655,7 +657,7 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -676,7 +678,7 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -745,6 +747,8 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AllocationUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1221,7 +1225,7 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1242,7 +1246,7 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1263,7 +1267,7 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1284,7 +1288,7 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs
index 076ecad0f..cf46ba9f8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs
@@ -87,7 +87,7 @@ public class AnalysisCaseDefinitionReader : XmiDataReader<IAnalysisCaseDefinitio
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AnalysisCaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AnalysisCaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AnalysisCaseDefinitionReader>.Instance : loggerFactory.CreateLogger<AnalysisCaseDefinitionReader>();
         }
@@ -133,6 +133,8 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AnalysisCaseDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -371,7 +373,7 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -392,7 +394,7 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -449,6 +451,8 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AnalysisCaseDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -687,7 +691,7 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -708,7 +712,7 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs
index 6711c1e9e..15486d604 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs
@@ -90,7 +90,7 @@ public class AnalysisCaseUsageReader : XmiDataReader<IAnalysisCaseUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AnalysisCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AnalysisCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AnalysisCaseUsageReader>.Instance : loggerFactory.CreateLogger<AnalysisCaseUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AnalysisCaseUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AnalysisCaseUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs
index 8fc9178cb..e1c129add 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs
@@ -60,7 +60,7 @@ public class AnnotatingElementReader : XmiDataReader<IAnnotatingElement>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AnnotatingElementReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AnnotatingElementReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AnnotatingElementReader>.Instance : loggerFactory.CreateLogger<AnnotatingElementReader>();
         }
@@ -106,6 +106,8 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AnnotatingElement", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -256,7 +258,7 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -277,7 +279,7 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -334,6 +336,8 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AnnotatingElement", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -484,7 +488,7 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -505,7 +509,7 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs
index 954d5446e..625d4294a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs
@@ -60,7 +60,7 @@ public class AnnotationReader : XmiDataReader<IAnnotation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AnnotationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AnnotationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AnnotationReader>.Instance : loggerFactory.CreateLogger<AnnotationReader>();
         }
@@ -106,6 +106,8 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Annotation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -258,7 +260,7 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var annotatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var annotatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.AnnotatedElement = annotatedElementValue;
                                     }
@@ -339,7 +341,7 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -360,7 +362,7 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -381,7 +383,7 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -402,7 +404,7 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -459,6 +461,8 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Annotation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -611,7 +615,7 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var annotatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var annotatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.AnnotatedElement = annotatedElementValue;
                                     }
@@ -692,7 +696,7 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -713,7 +717,7 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -734,7 +738,7 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -755,7 +759,7 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs
index 05a84fd1e..ff5bc3a68 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs
@@ -90,7 +90,7 @@ public class AssertConstraintUsageReader : XmiDataReader<IAssertConstraintUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AssertConstraintUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AssertConstraintUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AssertConstraintUsageReader>.Instance : loggerFactory.CreateLogger<AssertConstraintUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AssertConstraintUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -582,7 +584,7 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -603,7 +605,7 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -672,6 +674,8 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AssertConstraintUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1118,7 +1122,7 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1139,7 +1143,7 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs
index 7311f46d3..3cc588da3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs
@@ -90,7 +90,7 @@ public class AssignmentActionUsageReader : XmiDataReader<IAssignmentActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AssignmentActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AssignmentActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AssignmentActionUsageReader>.Instance : loggerFactory.CreateLogger<AssignmentActionUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AssignmentActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AssignmentActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs
index ccf7b99f2..7357a957f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs
@@ -64,7 +64,7 @@ public class AssociationReader : XmiDataReader<IAssociation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AssociationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AssociationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AssociationReader>.Instance : loggerFactory.CreateLogger<AssociationReader>();
         }
@@ -110,6 +110,8 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Association", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -356,7 +358,7 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -377,7 +379,7 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -398,7 +400,7 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -419,7 +421,7 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -476,6 +478,8 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Association", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -722,7 +726,7 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -743,7 +747,7 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -764,7 +768,7 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -785,7 +789,7 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs
index 11e8b0f2a..16dab3e14 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs
@@ -65,7 +65,7 @@ public class AssociationStructureReader : XmiDataReader<IAssociationStructure>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AssociationStructureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AssociationStructureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AssociationStructureReader>.Instance : loggerFactory.CreateLogger<AssociationStructureReader>();
         }
@@ -111,6 +111,8 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AssociationStructure", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -357,7 +359,7 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -378,7 +380,7 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -399,7 +401,7 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -420,7 +422,7 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -477,6 +479,8 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AssociationStructure", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -723,7 +727,7 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -744,7 +748,7 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -765,7 +769,7 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -786,7 +790,7 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs
index 35f18d2c8..8849373f9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs
@@ -86,7 +86,7 @@ public class AttributeDefinitionReader : XmiDataReader<IAttributeDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AttributeDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AttributeDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AttributeDefinitionReader>.Instance : loggerFactory.CreateLogger<AttributeDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AttributeDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -348,7 +350,7 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -369,7 +371,7 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -426,6 +428,8 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AttributeDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -642,7 +646,7 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -663,7 +667,7 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs
index b4572c527..c8ac97548 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs
@@ -87,7 +87,7 @@ public class AttributeUsageReader : XmiDataReader<IAttributeUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AttributeUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public AttributeUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AttributeUsageReader>.Instance : loggerFactory.CreateLogger<AttributeUsageReader>();
         }
@@ -133,6 +133,8 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AttributeUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -525,7 +527,7 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -546,7 +548,7 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -603,6 +605,8 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AttributeUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -995,7 +999,7 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1016,7 +1020,7 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs
index 998412e4f..f4b03f555 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs
@@ -65,7 +65,7 @@ public class BehaviorReader : XmiDataReader<IBehavior>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public BehaviorReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public BehaviorReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<BehaviorReader>.Instance : loggerFactory.CreateLogger<BehaviorReader>();
         }
@@ -111,6 +111,8 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Behavior", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -305,7 +307,7 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -326,7 +328,7 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -383,6 +385,8 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Behavior", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -577,7 +581,7 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -598,7 +602,7 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs
index aa9b86f7a..b564d34ba 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs
@@ -88,7 +88,7 @@ public class BindingConnectorAsUsageReader : XmiDataReader<IBindingConnectorAsUs
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public BindingConnectorAsUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public BindingConnectorAsUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<BindingConnectorAsUsageReader>.Instance : loggerFactory.CreateLogger<BindingConnectorAsUsageReader>();
         }
@@ -134,6 +134,8 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "BindingConnectorAsUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -578,7 +580,7 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -599,7 +601,7 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -620,7 +622,7 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -641,7 +643,7 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -698,6 +700,8 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "BindingConnectorAsUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1142,7 +1146,7 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1163,7 +1167,7 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1184,7 +1188,7 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1205,7 +1209,7 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs
index 9a40b7849..db51ccd68 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs
@@ -65,7 +65,7 @@ public class BindingConnectorReader : XmiDataReader<IBindingConnector>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public BindingConnectorReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public BindingConnectorReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<BindingConnectorReader>.Instance : loggerFactory.CreateLogger<BindingConnectorReader>();
         }
@@ -111,6 +111,8 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "BindingConnector", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -555,7 +557,7 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -576,7 +578,7 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -597,7 +599,7 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -618,7 +620,7 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -675,6 +677,8 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "BindingConnector", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1119,7 +1123,7 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1140,7 +1144,7 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1161,7 +1165,7 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1182,7 +1186,7 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs
index 0136c897b..8ee41bac1 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs
@@ -65,7 +65,7 @@ public class BooleanExpressionReader : XmiDataReader<IBooleanExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public BooleanExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public BooleanExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<BooleanExpressionReader>.Instance : loggerFactory.CreateLogger<BooleanExpressionReader>();
         }
@@ -111,6 +111,8 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "BooleanExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -503,7 +505,7 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -524,7 +526,7 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -581,6 +583,8 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "BooleanExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -973,7 +977,7 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -994,7 +998,7 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs
index 683e6af2b..fa19345e4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs
@@ -87,7 +87,7 @@ public class CalculationDefinitionReader : XmiDataReader<ICalculationDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public CalculationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public CalculationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CalculationDefinitionReader>.Instance : loggerFactory.CreateLogger<CalculationDefinitionReader>();
         }
@@ -133,6 +133,8 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CalculationDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -371,7 +373,7 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -392,7 +394,7 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -449,6 +451,8 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CalculationDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -687,7 +691,7 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -708,7 +712,7 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs
index 5d5a154c5..9e9749d6f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs
@@ -90,7 +90,7 @@ public class CalculationUsageReader : XmiDataReader<ICalculationUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public CalculationUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public CalculationUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CalculationUsageReader>.Instance : loggerFactory.CreateLogger<CalculationUsageReader>();
         }
@@ -136,6 +136,8 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CalculationUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CalculationUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs
index fc614ccae..a6dc48ce7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs
@@ -87,7 +87,7 @@ public class CaseDefinitionReader : XmiDataReader<ICaseDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public CaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public CaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CaseDefinitionReader>.Instance : loggerFactory.CreateLogger<CaseDefinitionReader>();
         }
@@ -133,6 +133,8 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CaseDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -371,7 +373,7 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -392,7 +394,7 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -449,6 +451,8 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CaseDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -687,7 +691,7 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -708,7 +712,7 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs
index bb080006c..857ee1a3f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs
@@ -90,7 +90,7 @@ public class CaseUsageReader : XmiDataReader<ICaseUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public CaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public CaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CaseUsageReader>.Instance : loggerFactory.CreateLogger<CaseUsageReader>();
         }
@@ -136,6 +136,8 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CaseUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CaseUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs
index c1758bcd4..5cfabf509 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs
@@ -64,7 +64,7 @@ public class ClassReader : XmiDataReader<IClass>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ClassReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ClassReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ClassReader>.Instance : loggerFactory.CreateLogger<ClassReader>();
         }
@@ -110,6 +110,8 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Class", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -304,7 +306,7 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -325,7 +327,7 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -382,6 +384,8 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Class", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -576,7 +580,7 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -597,7 +601,7 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs
index 186383511..2219db3e7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs
@@ -63,7 +63,7 @@ public class ClassifierReader : XmiDataReader<IClassifier>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ClassifierReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ClassifierReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ClassifierReader>.Instance : loggerFactory.CreateLogger<ClassifierReader>();
         }
@@ -109,6 +109,8 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Classifier", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -303,7 +305,7 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -324,7 +326,7 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -381,6 +383,8 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Classifier", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -575,7 +579,7 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -596,7 +600,7 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs
index a79f620d2..eac3938d2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs
@@ -66,7 +66,7 @@ public class CollectExpressionReader : XmiDataReader<ICollectExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public CollectExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public CollectExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CollectExpressionReader>.Instance : loggerFactory.CreateLogger<CollectExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CollectExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -523,7 +525,7 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -544,7 +546,7 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -601,6 +603,8 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CollectExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1012,7 +1016,7 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1033,7 +1037,7 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs
index 170e4edf9..50e095542 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs
@@ -60,7 +60,7 @@ public class CommentReader : XmiDataReader<IComment>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public CommentReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public CommentReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CommentReader>.Instance : loggerFactory.CreateLogger<CommentReader>();
         }
@@ -106,6 +106,8 @@ public override IComment Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Comment", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -294,7 +296,7 @@ public override IComment Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -315,7 +317,7 @@ public override IComment Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -372,6 +374,8 @@ public override async Task<IComment> ReadAsync(XmlReader xmiReader, Uri currentL
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Comment", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +564,7 @@ public override async Task<IComment> ReadAsync(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +585,7 @@ public override async Task<IComment> ReadAsync(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs
index 6c1d6c156..cbfec0828 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs
@@ -87,7 +87,7 @@ public class ConcernDefinitionReader : XmiDataReader<IConcernDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConcernDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConcernDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConcernDefinitionReader>.Instance : loggerFactory.CreateLogger<ConcernDefinitionReader>();
         }
@@ -133,6 +133,8 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConcernDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -359,7 +361,7 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -380,7 +382,7 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -449,6 +451,8 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConcernDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -675,7 +679,7 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -696,7 +700,7 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs
index 673877970..a11d7792f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs
@@ -90,7 +90,7 @@ public class ConcernUsageReader : XmiDataReader<IConcernUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConcernUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConcernUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConcernUsageReader>.Instance : loggerFactory.CreateLogger<ConcernUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConcernUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -548,7 +550,7 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -569,7 +571,7 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConcernUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1062,7 +1066,7 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1083,7 +1087,7 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs
index d7788f8bf..b74c75e32 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs
@@ -85,7 +85,7 @@ public class ConjugatedPortDefinitionReader : XmiDataReader<IConjugatedPortDefin
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConjugatedPortDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConjugatedPortDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConjugatedPortDefinitionReader>.Instance : loggerFactory.CreateLogger<ConjugatedPortDefinitionReader>();
         }
@@ -131,6 +131,8 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConjugatedPortDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -369,7 +371,7 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -390,7 +392,7 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -447,6 +449,8 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConjugatedPortDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -685,7 +689,7 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -706,7 +710,7 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs
index 4b2c6b65c..4b40a7a32 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs
@@ -63,7 +63,7 @@ public class ConjugatedPortTypingReader : XmiDataReader<IConjugatedPortTyping>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConjugatedPortTypingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConjugatedPortTypingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConjugatedPortTypingReader>.Instance : loggerFactory.CreateLogger<ConjugatedPortTypingReader>();
         }
@@ -109,6 +109,8 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConjugatedPortTyping", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -271,7 +273,7 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var conjugatedPortDefinitionValue = (IConjugatedPortDefinition)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var conjugatedPortDefinitionValue = (IConjugatedPortDefinition)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ConjugatedPortDefinition = conjugatedPortDefinitionValue;
                                     }
@@ -352,7 +354,7 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -373,7 +375,7 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -394,7 +396,7 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -415,7 +417,7 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -436,7 +438,7 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var typedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.TypedFeature = typedFeatureValue;
                                     }
@@ -493,6 +495,8 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConjugatedPortTyping", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -655,7 +659,7 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var conjugatedPortDefinitionValue = (IConjugatedPortDefinition)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var conjugatedPortDefinitionValue = (IConjugatedPortDefinition)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ConjugatedPortDefinition = conjugatedPortDefinitionValue;
                                     }
@@ -736,7 +740,7 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -757,7 +761,7 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -778,7 +782,7 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -799,7 +803,7 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -820,7 +824,7 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var typedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.TypedFeature = typedFeatureValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs
index ab8533117..54f56de55 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs
@@ -61,7 +61,7 @@ public class ConjugationReader : XmiDataReader<IConjugation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConjugationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConjugationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConjugationReader>.Instance : loggerFactory.CreateLogger<ConjugationReader>();
         }
@@ -107,6 +107,8 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Conjugation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -269,7 +271,7 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var conjugatedTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var conjugatedTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ConjugatedType = conjugatedTypeValue;
                                     }
@@ -350,7 +352,7 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var originalTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var originalTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.OriginalType = originalTypeValue;
                                     }
@@ -371,7 +373,7 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -392,7 +394,7 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -413,7 +415,7 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -434,7 +436,7 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -491,6 +493,8 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Conjugation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -653,7 +657,7 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var conjugatedTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var conjugatedTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ConjugatedType = conjugatedTypeValue;
                                     }
@@ -734,7 +738,7 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var originalTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var originalTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.OriginalType = originalTypeValue;
                                     }
@@ -755,7 +759,7 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -776,7 +780,7 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -797,7 +801,7 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -818,7 +822,7 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs
index 75004ee56..c89a97ae8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs
@@ -86,7 +86,7 @@ public class ConnectionDefinitionReader : XmiDataReader<IConnectionDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConnectionDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConnectionDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConnectionDefinitionReader>.Instance : loggerFactory.CreateLogger<ConnectionDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConnectionDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -422,7 +424,7 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -443,7 +445,7 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -464,7 +466,7 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -485,7 +487,7 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -542,6 +544,8 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConnectionDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -832,7 +836,7 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -853,7 +857,7 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -874,7 +878,7 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -895,7 +899,7 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs
index 05efa2ac8..c8596b18b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs
@@ -91,7 +91,7 @@ public class ConnectionUsageReader : XmiDataReader<IConnectionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConnectionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConnectionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConnectionUsageReader>.Instance : loggerFactory.CreateLogger<ConnectionUsageReader>();
         }
@@ -137,6 +137,8 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConnectionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -613,7 +615,7 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -634,7 +636,7 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -655,7 +657,7 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -676,7 +678,7 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -745,6 +747,8 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConnectionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1221,7 +1225,7 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1242,7 +1246,7 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1263,7 +1267,7 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1284,7 +1288,7 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs
index 85fd92756..c90ff0f25 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs
@@ -65,7 +65,7 @@ public class ConnectorReader : XmiDataReader<IConnector>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConnectorReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConnectorReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConnectorReader>.Instance : loggerFactory.CreateLogger<ConnectorReader>();
         }
@@ -111,6 +111,8 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Connector", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -555,7 +557,7 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -576,7 +578,7 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -597,7 +599,7 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -618,7 +620,7 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -675,6 +677,8 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Connector", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1119,7 +1123,7 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1140,7 +1144,7 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1161,7 +1165,7 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1182,7 +1186,7 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs
index af10e8709..780c35829 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs
@@ -87,7 +87,7 @@ public class ConstraintDefinitionReader : XmiDataReader<IConstraintDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConstraintDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConstraintDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConstraintDefinitionReader>.Instance : loggerFactory.CreateLogger<ConstraintDefinitionReader>();
         }
@@ -133,6 +133,8 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConstraintDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -371,7 +373,7 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -392,7 +394,7 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -449,6 +451,8 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConstraintDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -687,7 +691,7 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -708,7 +712,7 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs
index 1b568b5f1..0f2f25753 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs
@@ -90,7 +90,7 @@ public class ConstraintUsageReader : XmiDataReader<IConstraintUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConstraintUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConstraintUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConstraintUsageReader>.Instance : loggerFactory.CreateLogger<ConstraintUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConstraintUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConstraintUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs
index 72ab75a45..b7f3c0d1c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs
@@ -66,7 +66,7 @@ public class ConstructorExpressionReader : XmiDataReader<IConstructorExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ConstructorExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ConstructorExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConstructorExpressionReader>.Instance : loggerFactory.CreateLogger<ConstructorExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConstructorExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -504,7 +506,7 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -525,7 +527,7 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -582,6 +584,8 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ConstructorExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -974,7 +978,7 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -995,7 +999,7 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs
index da7f31b6b..178470ac4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs
@@ -62,7 +62,7 @@ public class CrossSubsettingReader : XmiDataReader<ICrossSubsetting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public CrossSubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public CrossSubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CrossSubsettingReader>.Instance : loggerFactory.CreateLogger<CrossSubsettingReader>();
         }
@@ -108,6 +108,8 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CrossSubsetting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -260,7 +262,7 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var crossedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var crossedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.CrossedFeature = crossedFeatureValue;
                                     }
@@ -341,7 +343,7 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -362,7 +364,7 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -383,7 +385,7 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -404,7 +406,7 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -461,6 +463,8 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "CrossSubsetting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -613,7 +617,7 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var crossedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var crossedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.CrossedFeature = crossedFeatureValue;
                                     }
@@ -694,7 +698,7 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -715,7 +719,7 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -736,7 +740,7 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -757,7 +761,7 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs
index 9c78352ac..7911b81a8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs
@@ -64,7 +64,7 @@ public class DataTypeReader : XmiDataReader<IDataType>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public DataTypeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public DataTypeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DataTypeReader>.Instance : loggerFactory.CreateLogger<DataTypeReader>();
         }
@@ -110,6 +110,8 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "DataType", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -304,7 +306,7 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -325,7 +327,7 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -382,6 +384,8 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "DataType", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -576,7 +580,7 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -597,7 +601,7 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs
index 940e8818f..7a38e20d1 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs
@@ -89,7 +89,7 @@ public class DecisionNodeReader : XmiDataReader<IDecisionNode>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public DecisionNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public DecisionNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DecisionNodeReader>.Instance : loggerFactory.CreateLogger<DecisionNodeReader>();
         }
@@ -135,6 +135,8 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "DecisionNode", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -559,7 +561,7 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -580,7 +582,7 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -649,6 +651,8 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "DecisionNode", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1073,7 +1077,7 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1094,7 +1098,7 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs
index 53c8c50e4..056348dde 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs
@@ -85,7 +85,7 @@ public class DefinitionReader : XmiDataReader<IDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public DefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public DefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DefinitionReader>.Instance : loggerFactory.CreateLogger<DefinitionReader>();
         }
@@ -131,6 +131,8 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Definition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -347,7 +349,7 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -368,7 +370,7 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -425,6 +427,8 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Definition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -641,7 +645,7 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -662,7 +666,7 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs
index 6de94ece1..397f6d8f6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs
@@ -61,7 +61,7 @@ public class DependencyReader : XmiDataReader<IDependency>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public DependencyReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public DependencyReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DependencyReader>.Instance : loggerFactory.CreateLogger<DependencyReader>();
         }
@@ -107,6 +107,8 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Dependency", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -289,7 +291,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var clientValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var clientValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Client.Add(clientValue);
                                     }
@@ -370,7 +372,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -391,7 +393,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -412,7 +414,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -433,7 +435,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -454,7 +456,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var supplierValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var supplierValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Supplier.Add(supplierValue);
                                     }
@@ -511,6 +513,8 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Dependency", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -693,7 +697,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var clientValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var clientValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Client.Add(clientValue);
                                     }
@@ -774,7 +778,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -795,7 +799,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -816,7 +820,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -837,7 +841,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -858,7 +862,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var supplierValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var supplierValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Supplier.Add(supplierValue);
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs
index dd2bd3efe..ff794622e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs
@@ -61,7 +61,7 @@ public class DifferencingReader : XmiDataReader<IDifferencing>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public DifferencingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public DifferencingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DifferencingReader>.Instance : loggerFactory.CreateLogger<DifferencingReader>();
         }
@@ -107,6 +107,8 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Differencing", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -283,7 +285,7 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var differencingTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var differencingTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.DifferencingType = differencingTypeValue;
                                     }
@@ -340,7 +342,7 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -361,7 +363,7 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -382,7 +384,7 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -403,7 +405,7 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -460,6 +462,8 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Differencing", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -636,7 +640,7 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var differencingTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var differencingTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.DifferencingType = differencingTypeValue;
                                     }
@@ -693,7 +697,7 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -714,7 +718,7 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -735,7 +739,7 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -756,7 +760,7 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs
index 1a242070d..095a834ac 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs
@@ -61,7 +61,7 @@ public class DisjoiningReader : XmiDataReader<IDisjoining>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public DisjoiningReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public DisjoiningReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DisjoiningReader>.Instance : loggerFactory.CreateLogger<DisjoiningReader>();
         }
@@ -107,6 +107,8 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Disjoining", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -293,7 +295,7 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var disjoiningTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var disjoiningTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.DisjoiningType = disjoiningTypeValue;
                                     }
@@ -350,7 +352,7 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -371,7 +373,7 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -392,7 +394,7 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -413,7 +415,7 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -434,7 +436,7 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var typeDisjoinedValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typeDisjoinedValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.TypeDisjoined = typeDisjoinedValue;
                                     }
@@ -491,6 +493,8 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Disjoining", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -677,7 +681,7 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var disjoiningTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var disjoiningTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.DisjoiningType = disjoiningTypeValue;
                                     }
@@ -734,7 +738,7 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -755,7 +759,7 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -776,7 +780,7 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -797,7 +801,7 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -818,7 +822,7 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var typeDisjoinedValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typeDisjoinedValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.TypeDisjoined = typeDisjoinedValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs
index bc6543019..b7aae163b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs
@@ -60,7 +60,7 @@ public class DocumentationReader : XmiDataReader<IDocumentation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public DocumentationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public DocumentationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DocumentationReader>.Instance : loggerFactory.CreateLogger<DocumentationReader>();
         }
@@ -106,6 +106,8 @@ public override IDocumentation Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Documentation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -294,7 +296,7 @@ public override IDocumentation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -315,7 +317,7 @@ public override IDocumentation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -372,6 +374,8 @@ public override async Task<IDocumentation> ReadAsync(XmlReader xmiReader, Uri cu
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Documentation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +564,7 @@ public override async Task<IDocumentation> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +585,7 @@ public override async Task<IDocumentation> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs
index c3128110f..8abb0bbc4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs
@@ -63,7 +63,7 @@ public class ElementFilterMembershipReader : XmiDataReader<IElementFilterMembers
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ElementFilterMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ElementFilterMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ElementFilterMembershipReader>.Instance : loggerFactory.CreateLogger<ElementFilterMembershipReader>();
         }
@@ -109,6 +109,8 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ElementFilterMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -321,7 +323,7 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -342,7 +344,7 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -363,7 +365,7 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -384,7 +386,7 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -453,6 +455,8 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ElementFilterMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -665,7 +669,7 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -686,7 +690,7 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -707,7 +711,7 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -728,7 +732,7 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs
index 9df6c142f..82c44d161 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs
@@ -63,7 +63,7 @@ public class EndFeatureMembershipReader : XmiDataReader<IEndFeatureMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public EndFeatureMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public EndFeatureMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<EndFeatureMembershipReader>.Instance : loggerFactory.CreateLogger<EndFeatureMembershipReader>();
         }
@@ -109,6 +109,8 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "EndFeatureMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -321,7 +323,7 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -342,7 +344,7 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -363,7 +365,7 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -384,7 +386,7 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -453,6 +455,8 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "EndFeatureMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -665,7 +669,7 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -686,7 +690,7 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -707,7 +711,7 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -728,7 +732,7 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs
index 1abcad16c..d0908301b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs
@@ -85,7 +85,7 @@ public class EnumerationDefinitionReader : XmiDataReader<IEnumerationDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public EnumerationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public EnumerationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<EnumerationDefinitionReader>.Instance : loggerFactory.CreateLogger<EnumerationDefinitionReader>();
         }
@@ -131,6 +131,8 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "EnumerationDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -347,7 +349,7 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -368,7 +370,7 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -425,6 +427,8 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "EnumerationDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -641,7 +645,7 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -662,7 +666,7 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs
index 745511aed..26ab5476c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs
@@ -87,7 +87,7 @@ public class EnumerationUsageReader : XmiDataReader<IEnumerationUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public EnumerationUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public EnumerationUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<EnumerationUsageReader>.Instance : loggerFactory.CreateLogger<EnumerationUsageReader>();
         }
@@ -133,6 +133,8 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "EnumerationUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -525,7 +527,7 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -546,7 +548,7 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -603,6 +605,8 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "EnumerationUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -995,7 +999,7 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1016,7 +1020,7 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs
index 9f2a55a8e..0ad5a9838 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs
@@ -88,7 +88,7 @@ public class EventOccurrenceUsageReader : XmiDataReader<IEventOccurrenceUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public EventOccurrenceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public EventOccurrenceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<EventOccurrenceUsageReader>.Instance : loggerFactory.CreateLogger<EventOccurrenceUsageReader>();
         }
@@ -134,6 +134,8 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "EventOccurrenceUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -558,7 +560,7 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -579,7 +581,7 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -648,6 +650,8 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "EventOccurrenceUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1072,7 +1076,7 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1093,7 +1097,7 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs
index 4ce391bed..47590aaea 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs
@@ -89,7 +89,7 @@ public class ExhibitStateUsageReader : XmiDataReader<IExhibitStateUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ExhibitStateUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ExhibitStateUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ExhibitStateUsageReader>.Instance : loggerFactory.CreateLogger<ExhibitStateUsageReader>();
         }
@@ -135,6 +135,8 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ExhibitStateUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -581,7 +583,7 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -602,7 +604,7 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -671,6 +673,8 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ExhibitStateUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1117,7 +1121,7 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1138,7 +1142,7 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs
index 853b894f7..de3c24505 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs
@@ -65,7 +65,7 @@ public class ExpressionReader : XmiDataReader<IExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ExpressionReader>.Instance : loggerFactory.CreateLogger<ExpressionReader>();
         }
@@ -111,6 +111,8 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Expression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -503,7 +505,7 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -524,7 +526,7 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -581,6 +583,8 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Expression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -973,7 +977,7 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -994,7 +998,7 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs
index 647fd40b2..d41c76566 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs
@@ -66,7 +66,7 @@ public class FeatureChainExpressionReader : XmiDataReader<IFeatureChainExpressio
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FeatureChainExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FeatureChainExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureChainExpressionReader>.Instance : loggerFactory.CreateLogger<FeatureChainExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureChainExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -523,7 +525,7 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -544,7 +546,7 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -601,6 +603,8 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureChainExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1012,7 +1016,7 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1033,7 +1037,7 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs
index 90e8e7f9d..aaece05eb 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs
@@ -61,7 +61,7 @@ public class FeatureChainingReader : XmiDataReader<IFeatureChaining>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FeatureChainingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FeatureChainingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureChainingReader>.Instance : loggerFactory.CreateLogger<FeatureChainingReader>();
         }
@@ -107,6 +107,8 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureChaining", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -259,7 +261,7 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var chainingFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var chainingFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ChainingFeature = chainingFeatureValue;
                                     }
@@ -340,7 +342,7 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -361,7 +363,7 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -382,7 +384,7 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -403,7 +405,7 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -460,6 +462,8 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureChaining", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -612,7 +616,7 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var chainingFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var chainingFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ChainingFeature = chainingFeatureValue;
                                     }
@@ -693,7 +697,7 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -714,7 +718,7 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -735,7 +739,7 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -756,7 +760,7 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs
index 0309ab431..2309960ac 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs
@@ -61,7 +61,7 @@ public class FeatureInvertingReader : XmiDataReader<IFeatureInverting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FeatureInvertingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FeatureInvertingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureInvertingReader>.Instance : loggerFactory.CreateLogger<FeatureInvertingReader>();
         }
@@ -107,6 +107,8 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureInverting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -305,7 +307,7 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var featureInvertedValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var featureInvertedValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.FeatureInverted = featureInvertedValue;
                                     }
@@ -326,7 +328,7 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var invertingFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var invertingFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.InvertingFeature = invertingFeatureValue;
                                     }
@@ -371,7 +373,7 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -392,7 +394,7 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -413,7 +415,7 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -434,7 +436,7 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -491,6 +493,8 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureInverting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -689,7 +693,7 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var featureInvertedValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var featureInvertedValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.FeatureInverted = featureInvertedValue;
                                     }
@@ -710,7 +714,7 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var invertingFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var invertingFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.InvertingFeature = invertingFeatureValue;
                                     }
@@ -755,7 +759,7 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -776,7 +780,7 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -797,7 +801,7 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -818,7 +822,7 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs
index 6aae31a9d..76ddfe139 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs
@@ -63,7 +63,7 @@ public class FeatureMembershipReader : XmiDataReader<IFeatureMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FeatureMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FeatureMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureMembershipReader>.Instance : loggerFactory.CreateLogger<FeatureMembershipReader>();
         }
@@ -109,6 +109,8 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -321,7 +323,7 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -342,7 +344,7 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -363,7 +365,7 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -384,7 +386,7 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -453,6 +455,8 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -665,7 +669,7 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -686,7 +690,7 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -707,7 +711,7 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -728,7 +732,7 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs
index dcf987af4..9373f8739 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs
@@ -63,7 +63,7 @@ public class FeatureReader : XmiDataReader<IFeature>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureReader>.Instance : loggerFactory.CreateLogger<FeatureReader>();
         }
@@ -109,6 +109,8 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Feature", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -501,7 +503,7 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -522,7 +524,7 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -579,6 +581,8 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Feature", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -971,7 +975,7 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -992,7 +996,7 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs
index 1ee370c4e..da373fcfe 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs
@@ -66,7 +66,7 @@ public class FeatureReferenceExpressionReader : XmiDataReader<IFeatureReferenceE
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FeatureReferenceExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FeatureReferenceExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureReferenceExpressionReader>.Instance : loggerFactory.CreateLogger<FeatureReferenceExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureReferenceExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -504,7 +506,7 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -525,7 +527,7 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -582,6 +584,8 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureReferenceExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -974,7 +978,7 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -995,7 +999,7 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs
index c0ef37ab4..45b598bb7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs
@@ -62,7 +62,7 @@ public class FeatureTypingReader : XmiDataReader<IFeatureTyping>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FeatureTypingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FeatureTypingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureTypingReader>.Instance : loggerFactory.CreateLogger<FeatureTypingReader>();
         }
@@ -108,6 +108,8 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureTyping", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -330,7 +332,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -351,7 +353,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -372,7 +374,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -393,7 +395,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -414,7 +416,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var typeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Type = typeValue;
                                     }
@@ -435,7 +437,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var typedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.TypedFeature = typedFeatureValue;
                                     }
@@ -492,6 +494,8 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureTyping", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -714,7 +718,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -735,7 +739,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -756,7 +760,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -777,7 +781,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -798,7 +802,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var typeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Type = typeValue;
                                     }
@@ -819,7 +823,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var typedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.TypedFeature = typedFeatureValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs
index 42662135e..e1c48ca1b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs
@@ -64,7 +64,7 @@ public class FeatureValueReader : XmiDataReader<IFeatureValue>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FeatureValueReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FeatureValueReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureValueReader>.Instance : loggerFactory.CreateLogger<FeatureValueReader>();
         }
@@ -110,6 +110,8 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureValue", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -366,7 +368,7 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -387,7 +389,7 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -408,7 +410,7 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -429,7 +431,7 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -498,6 +500,8 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureValue", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -754,7 +758,7 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -775,7 +779,7 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -796,7 +800,7 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -817,7 +821,7 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs
index 40a98ffd2..59e97e23d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs
@@ -88,7 +88,7 @@ public class FlowDefinitionReader : XmiDataReader<IFlowDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FlowDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FlowDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FlowDefinitionReader>.Instance : loggerFactory.CreateLogger<FlowDefinitionReader>();
         }
@@ -134,6 +134,8 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FlowDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -424,7 +426,7 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -445,7 +447,7 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -466,7 +468,7 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -487,7 +489,7 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -544,6 +546,8 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FlowDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -834,7 +838,7 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -855,7 +859,7 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -876,7 +880,7 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -897,7 +901,7 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs
index 43b446e32..937fb9502 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs
@@ -64,7 +64,7 @@ public class FlowEndReader : XmiDataReader<IFlowEnd>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FlowEndReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FlowEndReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FlowEndReader>.Instance : loggerFactory.CreateLogger<FlowEndReader>();
         }
@@ -110,6 +110,8 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FlowEnd", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -502,7 +504,7 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -523,7 +525,7 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -580,6 +582,8 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FlowEnd", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -972,7 +976,7 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -993,7 +997,7 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs
index 58d1dfaa5..68f1f66ae 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs
@@ -68,7 +68,7 @@ public class FlowReader : XmiDataReader<IFlow>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FlowReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FlowReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FlowReader>.Instance : loggerFactory.CreateLogger<FlowReader>();
         }
@@ -114,6 +114,8 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Flow", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -558,7 +560,7 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -579,7 +581,7 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -600,7 +602,7 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -621,7 +623,7 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -678,6 +680,8 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Flow", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1122,7 +1126,7 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1143,7 +1147,7 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1164,7 +1168,7 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1185,7 +1189,7 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs
index c4e4b70a1..631801be2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs
@@ -92,7 +92,7 @@ public class FlowUsageReader : XmiDataReader<IFlowUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FlowUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FlowUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FlowUsageReader>.Instance : loggerFactory.CreateLogger<FlowUsageReader>();
         }
@@ -138,6 +138,8 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FlowUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -614,7 +616,7 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -635,7 +637,7 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -656,7 +658,7 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -677,7 +679,7 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -746,6 +748,8 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FlowUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1222,7 +1226,7 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1243,7 +1247,7 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1264,7 +1268,7 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1285,7 +1289,7 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs
index 0d30f3117..0846e60bd 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs
@@ -90,7 +90,7 @@ public class ForLoopActionUsageReader : XmiDataReader<IForLoopActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ForLoopActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ForLoopActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ForLoopActionUsageReader>.Instance : loggerFactory.CreateLogger<ForLoopActionUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ForLoopActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ForLoopActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs
index 8b74189cc..388c4d705 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs
@@ -89,7 +89,7 @@ public class ForkNodeReader : XmiDataReader<IForkNode>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ForkNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ForkNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ForkNodeReader>.Instance : loggerFactory.CreateLogger<ForkNodeReader>();
         }
@@ -135,6 +135,8 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ForkNode", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -559,7 +561,7 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -580,7 +582,7 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -649,6 +651,8 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ForkNode", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1073,7 +1077,7 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1094,7 +1098,7 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs
index 1241d8d31..e1c07f8a0 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs
@@ -66,7 +66,7 @@ public class FramedConcernMembershipReader : XmiDataReader<IFramedConcernMembers
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FramedConcernMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FramedConcernMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FramedConcernMembershipReader>.Instance : loggerFactory.CreateLogger<FramedConcernMembershipReader>();
         }
@@ -112,6 +112,8 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FramedConcernMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -346,7 +348,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -367,7 +369,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -388,7 +390,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -409,7 +411,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -478,6 +480,8 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FramedConcernMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -712,7 +716,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -733,7 +737,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -754,7 +758,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -775,7 +779,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs
index 46fbcf7d3..ac75412bb 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs
@@ -65,7 +65,7 @@ public class FunctionReader : XmiDataReader<IFunction>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FunctionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public FunctionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FunctionReader>.Instance : loggerFactory.CreateLogger<FunctionReader>();
         }
@@ -111,6 +111,8 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Function", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -305,7 +307,7 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -326,7 +328,7 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -383,6 +385,8 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Function", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -577,7 +581,7 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -598,7 +602,7 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs
index 5a2e6ecf3..67811e63a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs
@@ -90,7 +90,7 @@ public class IfActionUsageReader : XmiDataReader<IIfActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public IfActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public IfActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<IfActionUsageReader>.Instance : loggerFactory.CreateLogger<IfActionUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "IfActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "IfActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs
index 584468bd6..0599268f6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs
@@ -90,7 +90,7 @@ public class IncludeUseCaseUsageReader : XmiDataReader<IIncludeUseCaseUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public IncludeUseCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public IncludeUseCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<IncludeUseCaseUsageReader>.Instance : loggerFactory.CreateLogger<IncludeUseCaseUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "IncludeUseCaseUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "IncludeUseCaseUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs
index b5a68f3bd..d5b4c8f0e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs
@@ -66,7 +66,7 @@ public class IndexExpressionReader : XmiDataReader<IIndexExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public IndexExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public IndexExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<IndexExpressionReader>.Instance : loggerFactory.CreateLogger<IndexExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "IndexExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -523,7 +525,7 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -544,7 +546,7 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -601,6 +603,8 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "IndexExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1012,7 +1016,7 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1033,7 +1037,7 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs
index 7e3040d98..f92062ac9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs
@@ -66,7 +66,7 @@ public class InteractionReader : XmiDataReader<IInteraction>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public InteractionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public InteractionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<InteractionReader>.Instance : loggerFactory.CreateLogger<InteractionReader>();
         }
@@ -112,6 +112,8 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Interaction", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -358,7 +360,7 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -379,7 +381,7 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -400,7 +402,7 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -421,7 +423,7 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -478,6 +480,8 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Interaction", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -724,7 +728,7 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -745,7 +749,7 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -766,7 +770,7 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -787,7 +791,7 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs
index 05f047fcf..98de4139d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs
@@ -86,7 +86,7 @@ public class InterfaceDefinitionReader : XmiDataReader<IInterfaceDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public InterfaceDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public InterfaceDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<InterfaceDefinitionReader>.Instance : loggerFactory.CreateLogger<InterfaceDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "InterfaceDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -422,7 +424,7 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -443,7 +445,7 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -464,7 +466,7 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -485,7 +487,7 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -542,6 +544,8 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "InterfaceDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -832,7 +836,7 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -853,7 +857,7 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -874,7 +878,7 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -895,7 +899,7 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs
index f01d8e912..8189fb2fc 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs
@@ -91,7 +91,7 @@ public class InterfaceUsageReader : XmiDataReader<IInterfaceUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public InterfaceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public InterfaceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<InterfaceUsageReader>.Instance : loggerFactory.CreateLogger<InterfaceUsageReader>();
         }
@@ -137,6 +137,8 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "InterfaceUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -613,7 +615,7 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -634,7 +636,7 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -655,7 +657,7 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -676,7 +678,7 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -745,6 +747,8 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "InterfaceUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1221,7 +1225,7 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1242,7 +1246,7 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1263,7 +1267,7 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1284,7 +1288,7 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs
index 553fed90d..ea29fba2a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs
@@ -61,7 +61,7 @@ public class IntersectingReader : XmiDataReader<IIntersecting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public IntersectingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public IntersectingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<IntersectingReader>.Instance : loggerFactory.CreateLogger<IntersectingReader>();
         }
@@ -107,6 +107,8 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Intersecting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -295,7 +297,7 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var intersectingTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var intersectingTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.IntersectingType = intersectingTypeValue;
                                     }
@@ -340,7 +342,7 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -361,7 +363,7 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -382,7 +384,7 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -403,7 +405,7 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -460,6 +462,8 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Intersecting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -648,7 +652,7 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var intersectingTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var intersectingTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.IntersectingType = intersectingTypeValue;
                                     }
@@ -693,7 +697,7 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -714,7 +718,7 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -735,7 +739,7 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -756,7 +760,7 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs
index 8419fff0e..6f4dda851 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs
@@ -65,7 +65,7 @@ public class InvariantReader : XmiDataReader<IInvariant>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public InvariantReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public InvariantReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<InvariantReader>.Instance : loggerFactory.CreateLogger<InvariantReader>();
         }
@@ -111,6 +111,8 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Invariant", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -525,7 +527,7 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -546,7 +548,7 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -603,6 +605,8 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Invariant", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1017,7 +1021,7 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1038,7 +1042,7 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs
index c75147ba5..7a2e0728e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs
@@ -66,7 +66,7 @@ public class InvocationExpressionReader : XmiDataReader<IInvocationExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public InvocationExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public InvocationExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<InvocationExpressionReader>.Instance : loggerFactory.CreateLogger<InvocationExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "InvocationExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -504,7 +506,7 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -525,7 +527,7 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -582,6 +584,8 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "InvocationExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -974,7 +978,7 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -995,7 +999,7 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs
index 371551f65..e70f7ed2d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs
@@ -86,7 +86,7 @@ public class ItemDefinitionReader : XmiDataReader<IItemDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ItemDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ItemDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ItemDefinitionReader>.Instance : loggerFactory.CreateLogger<ItemDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ItemDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -370,7 +372,7 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -391,7 +393,7 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -448,6 +450,8 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ItemDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -686,7 +690,7 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -707,7 +711,7 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs
index a80dfd58b..8c9eba247 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs
@@ -89,7 +89,7 @@ public class ItemUsageReader : XmiDataReader<IItemUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ItemUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ItemUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ItemUsageReader>.Instance : loggerFactory.CreateLogger<ItemUsageReader>();
         }
@@ -135,6 +135,8 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ItemUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -559,7 +561,7 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -580,7 +582,7 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -649,6 +651,8 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ItemUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1073,7 +1077,7 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1094,7 +1098,7 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs
index 7dfcafad7..4dde20261 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs
@@ -89,7 +89,7 @@ public class JoinNodeReader : XmiDataReader<IJoinNode>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public JoinNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public JoinNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<JoinNodeReader>.Instance : loggerFactory.CreateLogger<JoinNodeReader>();
         }
@@ -135,6 +135,8 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "JoinNode", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -559,7 +561,7 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -580,7 +582,7 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -649,6 +651,8 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "JoinNode", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1073,7 +1077,7 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1094,7 +1098,7 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs
index e5412779c..09e6ca57a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs
@@ -62,7 +62,7 @@ public class LibraryPackageReader : XmiDataReader<ILibraryPackage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public LibraryPackageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public LibraryPackageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LibraryPackageReader>.Instance : loggerFactory.CreateLogger<LibraryPackageReader>();
         }
@@ -108,6 +108,8 @@ public override ILibraryPackage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LibraryPackage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -280,7 +282,7 @@ public override ILibraryPackage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -301,7 +303,7 @@ public override ILibraryPackage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -358,6 +360,8 @@ public override async Task<ILibraryPackage> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LibraryPackage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -530,7 +534,7 @@ public override async Task<ILibraryPackage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -551,7 +555,7 @@ public override async Task<ILibraryPackage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs
index a7a13c142..b250c703e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs
@@ -66,7 +66,7 @@ public class LiteralBooleanReader : XmiDataReader<ILiteralBoolean>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public LiteralBooleanReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public LiteralBooleanReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralBooleanReader>.Instance : loggerFactory.CreateLogger<LiteralBooleanReader>();
         }
@@ -112,6 +112,8 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralBoolean", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -514,7 +516,7 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -535,7 +537,7 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -604,6 +606,8 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralBoolean", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1006,7 +1010,7 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1027,7 +1031,7 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs
index 5c9a513ce..eeb6ca8d6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs
@@ -66,7 +66,7 @@ public class LiteralExpressionReader : XmiDataReader<ILiteralExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public LiteralExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public LiteralExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralExpressionReader>.Instance : loggerFactory.CreateLogger<LiteralExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -504,7 +506,7 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -525,7 +527,7 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -582,6 +584,8 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -974,7 +978,7 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -995,7 +999,7 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs
index b7064d4c4..8bd5913fc 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs
@@ -66,7 +66,7 @@ public class LiteralInfinityReader : XmiDataReader<ILiteralInfinity>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public LiteralInfinityReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public LiteralInfinityReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralInfinityReader>.Instance : loggerFactory.CreateLogger<LiteralInfinityReader>();
         }
@@ -112,6 +112,8 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralInfinity", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -504,7 +506,7 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -525,7 +527,7 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -582,6 +584,8 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralInfinity", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -974,7 +978,7 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -995,7 +999,7 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs
index dfaf84eb0..80e2d97f7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs
@@ -66,7 +66,7 @@ public class LiteralIntegerReader : XmiDataReader<ILiteralInteger>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public LiteralIntegerReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public LiteralIntegerReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralIntegerReader>.Instance : loggerFactory.CreateLogger<LiteralIntegerReader>();
         }
@@ -112,6 +112,8 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralInteger", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -514,7 +516,7 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -535,7 +537,7 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -604,6 +606,8 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralInteger", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1006,7 +1010,7 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1027,7 +1031,7 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs
index 23c2276b3..03e6f6423 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs
@@ -66,7 +66,7 @@ public class LiteralRationalReader : XmiDataReader<ILiteralRational>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public LiteralRationalReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public LiteralRationalReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralRationalReader>.Instance : loggerFactory.CreateLogger<LiteralRationalReader>();
         }
@@ -112,6 +112,8 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralRational", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -514,7 +516,7 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -535,7 +537,7 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -604,6 +606,8 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralRational", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1006,7 +1010,7 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1027,7 +1031,7 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs
index 9a5348467..8460c6eb6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs
@@ -66,7 +66,7 @@ public class LiteralStringReader : XmiDataReader<ILiteralString>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public LiteralStringReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public LiteralStringReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralStringReader>.Instance : loggerFactory.CreateLogger<LiteralStringReader>();
         }
@@ -112,6 +112,8 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralString", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -511,7 +513,7 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -532,7 +534,7 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -601,6 +603,8 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralString", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1000,7 +1004,7 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1021,7 +1025,7 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs
index 190e51c5b..ffb6c83e0 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs
@@ -62,7 +62,7 @@ public class MembershipExposeReader : XmiDataReader<IMembershipExpose>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MembershipExposeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MembershipExposeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MembershipExposeReader>.Instance : loggerFactory.CreateLogger<MembershipExposeReader>();
         }
@@ -108,6 +108,8 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MembershipExpose", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -326,7 +328,7 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var importedMembershipValue = (IMembership)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var importedMembershipValue = (IMembership)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ImportedMembership = importedMembershipValue;
                                     }
@@ -395,7 +397,7 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -416,7 +418,7 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -437,7 +439,7 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -458,7 +460,7 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -527,6 +529,8 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MembershipExpose", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -745,7 +749,7 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var importedMembershipValue = (IMembership)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var importedMembershipValue = (IMembership)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ImportedMembership = importedMembershipValue;
                                     }
@@ -814,7 +818,7 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -835,7 +839,7 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -856,7 +860,7 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -877,7 +881,7 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs
index aa620872c..529f16caa 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs
@@ -61,7 +61,7 @@ public class MembershipImportReader : XmiDataReader<IMembershipImport>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MembershipImportReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MembershipImportReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MembershipImportReader>.Instance : loggerFactory.CreateLogger<MembershipImportReader>();
         }
@@ -107,6 +107,8 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MembershipImport", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -325,7 +327,7 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var importedMembershipValue = (IMembership)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var importedMembershipValue = (IMembership)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ImportedMembership = importedMembershipValue;
                                     }
@@ -394,7 +396,7 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -415,7 +417,7 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -436,7 +438,7 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -457,7 +459,7 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -526,6 +528,8 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MembershipImport", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -744,7 +748,7 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var importedMembershipValue = (IMembership)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var importedMembershipValue = (IMembership)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ImportedMembership = importedMembershipValue;
                                     }
@@ -813,7 +817,7 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -834,7 +838,7 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -855,7 +859,7 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -876,7 +880,7 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs
index 7bfacadba..82b386bf2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs
@@ -61,7 +61,7 @@ public class MembershipReader : XmiDataReader<IMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MembershipReader>.Instance : loggerFactory.CreateLogger<MembershipReader>();
         }
@@ -107,6 +107,8 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Membership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -343,7 +345,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var memberElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var memberElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.MemberElement = memberElementValue;
                                     }
@@ -388,7 +390,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -409,7 +411,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -430,7 +432,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -451,7 +453,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -520,6 +522,8 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Membership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -756,7 +760,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var memberElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var memberElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.MemberElement = memberElementValue;
                                     }
@@ -801,7 +805,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -822,7 +826,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -843,7 +847,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -864,7 +868,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs
index a6861a7e5..e48bf552a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs
@@ -89,7 +89,7 @@ public class MergeNodeReader : XmiDataReader<IMergeNode>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MergeNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MergeNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MergeNodeReader>.Instance : loggerFactory.CreateLogger<MergeNodeReader>();
         }
@@ -135,6 +135,8 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MergeNode", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -559,7 +561,7 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -580,7 +582,7 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -649,6 +651,8 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MergeNode", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1073,7 +1077,7 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1094,7 +1098,7 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs
index de6ddfe7f..d1d7721b7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs
@@ -65,7 +65,7 @@ public class MetaclassReader : XmiDataReader<IMetaclass>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MetaclassReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MetaclassReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MetaclassReader>.Instance : loggerFactory.CreateLogger<MetaclassReader>();
         }
@@ -111,6 +111,8 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Metaclass", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -305,7 +307,7 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -326,7 +328,7 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -383,6 +385,8 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Metaclass", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -577,7 +581,7 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -598,7 +602,7 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs
index 45f863ba8..5c4de7157 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs
@@ -66,7 +66,7 @@ public class MetadataAccessExpressionReader : XmiDataReader<IMetadataAccessExpre
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MetadataAccessExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MetadataAccessExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MetadataAccessExpressionReader>.Instance : loggerFactory.CreateLogger<MetadataAccessExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MetadataAccessExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -504,7 +506,7 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -525,7 +527,7 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -582,6 +584,8 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MetadataAccessExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -974,7 +978,7 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -995,7 +999,7 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs
index 56f92a2f3..5bdafe905 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs
@@ -86,7 +86,7 @@ public class MetadataDefinitionReader : XmiDataReader<IMetadataDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MetadataDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MetadataDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MetadataDefinitionReader>.Instance : loggerFactory.CreateLogger<MetadataDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MetadataDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -370,7 +372,7 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -391,7 +393,7 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -448,6 +450,8 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MetadataDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -686,7 +690,7 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -707,7 +711,7 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs
index 7f870e8dd..7a69a6b07 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs
@@ -64,7 +64,7 @@ public class MetadataFeatureReader : XmiDataReader<IMetadataFeature>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MetadataFeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MetadataFeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MetadataFeatureReader>.Instance : loggerFactory.CreateLogger<MetadataFeatureReader>();
         }
@@ -110,6 +110,8 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MetadataFeature", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -502,7 +504,7 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -523,7 +525,7 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -580,6 +582,8 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MetadataFeature", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -972,7 +976,7 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -993,7 +997,7 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs
index 26282f0b3..84bb3799f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs
@@ -90,7 +90,7 @@ public class MetadataUsageReader : XmiDataReader<IMetadataUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MetadataUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MetadataUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MetadataUsageReader>.Instance : loggerFactory.CreateLogger<MetadataUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MetadataUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MetadataUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs
index 85f674c48..04fd064a6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs
@@ -65,7 +65,7 @@ public class MultiplicityRangeReader : XmiDataReader<IMultiplicityRange>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MultiplicityRangeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MultiplicityRangeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MultiplicityRangeReader>.Instance : loggerFactory.CreateLogger<MultiplicityRangeReader>();
         }
@@ -111,6 +111,8 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MultiplicityRange", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -503,7 +505,7 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -524,7 +526,7 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -581,6 +583,8 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MultiplicityRange", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -973,7 +977,7 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -994,7 +998,7 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs
index 935058c00..4e899b25f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs
@@ -63,7 +63,7 @@ public class MultiplicityReader : XmiDataReader<IMultiplicity>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MultiplicityReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public MultiplicityReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MultiplicityReader>.Instance : loggerFactory.CreateLogger<MultiplicityReader>();
         }
@@ -109,6 +109,8 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Multiplicity", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -501,7 +503,7 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -522,7 +524,7 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -579,6 +581,8 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Multiplicity", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -971,7 +975,7 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -992,7 +996,7 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs
index 3c9bec70b..feabf7ff6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs
@@ -62,7 +62,7 @@ public class NamespaceExposeReader : XmiDataReader<INamespaceExpose>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public NamespaceExposeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public NamespaceExposeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<NamespaceExposeReader>.Instance : loggerFactory.CreateLogger<NamespaceExposeReader>();
         }
@@ -108,6 +108,8 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "NamespaceExpose", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -326,7 +328,7 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var importedNamespaceValue = (INamespace)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var importedNamespaceValue = (INamespace)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ImportedNamespace = importedNamespaceValue;
                                     }
@@ -395,7 +397,7 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -416,7 +418,7 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -437,7 +439,7 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -458,7 +460,7 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -527,6 +529,8 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "NamespaceExpose", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -745,7 +749,7 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var importedNamespaceValue = (INamespace)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var importedNamespaceValue = (INamespace)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ImportedNamespace = importedNamespaceValue;
                                     }
@@ -814,7 +818,7 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -835,7 +839,7 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -856,7 +860,7 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -877,7 +881,7 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs
index 351693382..353fed585 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs
@@ -61,7 +61,7 @@ public class NamespaceImportReader : XmiDataReader<INamespaceImport>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public NamespaceImportReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public NamespaceImportReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<NamespaceImportReader>.Instance : loggerFactory.CreateLogger<NamespaceImportReader>();
         }
@@ -107,6 +107,8 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "NamespaceImport", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -325,7 +327,7 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var importedNamespaceValue = (INamespace)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var importedNamespaceValue = (INamespace)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ImportedNamespace = importedNamespaceValue;
                                     }
@@ -394,7 +396,7 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -415,7 +417,7 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -436,7 +438,7 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -457,7 +459,7 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -526,6 +528,8 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "NamespaceImport", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -744,7 +748,7 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var importedNamespaceValue = (INamespace)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var importedNamespaceValue = (INamespace)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ImportedNamespace = importedNamespaceValue;
                                     }
@@ -813,7 +817,7 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -834,7 +838,7 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -855,7 +859,7 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -876,7 +880,7 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs
index c3f99b707..c7d8b3683 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs
@@ -60,7 +60,7 @@ public class NamespaceReader : XmiDataReader<INamespace>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public NamespaceReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public NamespaceReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<NamespaceReader>.Instance : loggerFactory.CreateLogger<NamespaceReader>();
         }
@@ -106,6 +106,8 @@ public override INamespace Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Namespace", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -256,7 +258,7 @@ public override INamespace Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -277,7 +279,7 @@ public override INamespace Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -334,6 +336,8 @@ public override async Task<INamespace> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Namespace", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -484,7 +488,7 @@ public override async Task<INamespace> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -505,7 +509,7 @@ public override async Task<INamespace> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs
index 4e9cf84f6..808b70160 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs
@@ -66,7 +66,7 @@ public class NullExpressionReader : XmiDataReader<INullExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public NullExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public NullExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<NullExpressionReader>.Instance : loggerFactory.CreateLogger<NullExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "NullExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -504,7 +506,7 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -525,7 +527,7 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -582,6 +584,8 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "NullExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -974,7 +978,7 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -995,7 +999,7 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs
index 96d216cf0..f3513bdff 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs
@@ -65,7 +65,7 @@ public class ObjectiveMembershipReader : XmiDataReader<IObjectiveMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ObjectiveMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ObjectiveMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ObjectiveMembershipReader>.Instance : loggerFactory.CreateLogger<ObjectiveMembershipReader>();
         }
@@ -111,6 +111,8 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ObjectiveMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -323,7 +325,7 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -344,7 +346,7 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -365,7 +367,7 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -386,7 +388,7 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -455,6 +457,8 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ObjectiveMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -667,7 +671,7 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -688,7 +692,7 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -709,7 +713,7 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -730,7 +734,7 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs
index 003c2b789..75af87f1c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs
@@ -86,7 +86,7 @@ public class OccurrenceDefinitionReader : XmiDataReader<IOccurrenceDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public OccurrenceDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public OccurrenceDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<OccurrenceDefinitionReader>.Instance : loggerFactory.CreateLogger<OccurrenceDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "OccurrenceDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -370,7 +372,7 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -391,7 +393,7 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -448,6 +450,8 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "OccurrenceDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -686,7 +690,7 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -707,7 +711,7 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs
index 0bfff368b..88b5dffb7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs
@@ -88,7 +88,7 @@ public class OccurrenceUsageReader : XmiDataReader<IOccurrenceUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public OccurrenceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public OccurrenceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<OccurrenceUsageReader>.Instance : loggerFactory.CreateLogger<OccurrenceUsageReader>();
         }
@@ -134,6 +134,8 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "OccurrenceUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -558,7 +560,7 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -579,7 +581,7 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -648,6 +650,8 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "OccurrenceUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1072,7 +1076,7 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1093,7 +1097,7 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs
index 3220900c9..416593639 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs
@@ -66,7 +66,7 @@ public class OperatorExpressionReader : XmiDataReader<IOperatorExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public OperatorExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public OperatorExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<OperatorExpressionReader>.Instance : loggerFactory.CreateLogger<OperatorExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "OperatorExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -523,7 +525,7 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -544,7 +546,7 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -601,6 +603,8 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "OperatorExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1012,7 +1016,7 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1033,7 +1037,7 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs
index f0bc91898..cc7e22998 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs
@@ -61,7 +61,7 @@ public class OwningMembershipReader : XmiDataReader<IOwningMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public OwningMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public OwningMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<OwningMembershipReader>.Instance : loggerFactory.CreateLogger<OwningMembershipReader>();
         }
@@ -107,6 +107,8 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "OwningMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -319,7 +321,7 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -340,7 +342,7 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -361,7 +363,7 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -382,7 +384,7 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -451,6 +453,8 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "OwningMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -663,7 +667,7 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -684,7 +688,7 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -705,7 +709,7 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -726,7 +730,7 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs
index 0bfa3e5dc..76defa21d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs
@@ -62,7 +62,7 @@ public class PackageReader : XmiDataReader<IPackage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public PackageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public PackageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PackageReader>.Instance : loggerFactory.CreateLogger<PackageReader>();
         }
@@ -108,6 +108,8 @@ public override IPackage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Package", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -258,7 +260,7 @@ public override IPackage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -279,7 +281,7 @@ public override IPackage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -336,6 +338,8 @@ public override async Task<IPackage> ReadAsync(XmlReader xmiReader, Uri currentL
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Package", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -486,7 +490,7 @@ public override async Task<IPackage> ReadAsync(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -507,7 +511,7 @@ public override async Task<IPackage> ReadAsync(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs
index 272a25a82..713b3338a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs
@@ -64,7 +64,7 @@ public class ParameterMembershipReader : XmiDataReader<IParameterMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ParameterMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ParameterMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ParameterMembershipReader>.Instance : loggerFactory.CreateLogger<ParameterMembershipReader>();
         }
@@ -110,6 +110,8 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ParameterMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -322,7 +324,7 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -343,7 +345,7 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -364,7 +366,7 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -385,7 +387,7 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -454,6 +456,8 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ParameterMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -666,7 +670,7 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -687,7 +691,7 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -708,7 +712,7 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -729,7 +733,7 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs
index 8fd555ef6..be58de6e4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs
@@ -85,7 +85,7 @@ public class PartDefinitionReader : XmiDataReader<IPartDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public PartDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public PartDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PartDefinitionReader>.Instance : loggerFactory.CreateLogger<PartDefinitionReader>();
         }
@@ -131,6 +131,8 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PartDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -369,7 +371,7 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -390,7 +392,7 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -447,6 +449,8 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PartDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -685,7 +689,7 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -706,7 +710,7 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs
index cb3b8c47a..060f30956 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs
@@ -89,7 +89,7 @@ public class PartUsageReader : XmiDataReader<IPartUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public PartUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public PartUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PartUsageReader>.Instance : loggerFactory.CreateLogger<PartUsageReader>();
         }
@@ -135,6 +135,8 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PartUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -559,7 +561,7 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -580,7 +582,7 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -649,6 +651,8 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PartUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1073,7 +1077,7 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1094,7 +1098,7 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs
index bcecdd87f..d5f6bb908 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs
@@ -64,7 +64,7 @@ public class PayloadFeatureReader : XmiDataReader<IPayloadFeature>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public PayloadFeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public PayloadFeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PayloadFeatureReader>.Instance : loggerFactory.CreateLogger<PayloadFeatureReader>();
         }
@@ -110,6 +110,8 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PayloadFeature", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -502,7 +504,7 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -523,7 +525,7 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -580,6 +582,8 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PayloadFeature", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -972,7 +976,7 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -993,7 +997,7 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs
index a90f7e585..5d470a655 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs
@@ -89,7 +89,7 @@ public class PerformActionUsageReader : XmiDataReader<IPerformActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public PerformActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public PerformActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PerformActionUsageReader>.Instance : loggerFactory.CreateLogger<PerformActionUsageReader>();
         }
@@ -135,6 +135,8 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PerformActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -559,7 +561,7 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -580,7 +582,7 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -649,6 +651,8 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PerformActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1073,7 +1077,7 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1094,7 +1098,7 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs
index da6cf3bbb..a244c3b3d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs
@@ -62,7 +62,7 @@ public class PortConjugationReader : XmiDataReader<IPortConjugation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public PortConjugationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public PortConjugationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PortConjugationReader>.Instance : loggerFactory.CreateLogger<PortConjugationReader>();
         }
@@ -108,6 +108,8 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PortConjugation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -270,7 +272,7 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var conjugatedTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var conjugatedTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ConjugatedType = conjugatedTypeValue;
                                     }
@@ -351,7 +353,7 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var originalPortDefinitionValue = (IPortDefinition)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var originalPortDefinitionValue = (IPortDefinition)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.OriginalPortDefinition = originalPortDefinitionValue;
                                     }
@@ -372,7 +374,7 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -393,7 +395,7 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -414,7 +416,7 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -435,7 +437,7 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -492,6 +494,8 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PortConjugation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -654,7 +658,7 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var conjugatedTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var conjugatedTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ConjugatedType = conjugatedTypeValue;
                                     }
@@ -735,7 +739,7 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var originalPortDefinitionValue = (IPortDefinition)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var originalPortDefinitionValue = (IPortDefinition)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.OriginalPortDefinition = originalPortDefinitionValue;
                                     }
@@ -756,7 +760,7 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -777,7 +781,7 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -798,7 +802,7 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -819,7 +823,7 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs
index 139542364..8d13820b8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs
@@ -86,7 +86,7 @@ public class PortDefinitionReader : XmiDataReader<IPortDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public PortDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public PortDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PortDefinitionReader>.Instance : loggerFactory.CreateLogger<PortDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PortDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -370,7 +372,7 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -391,7 +393,7 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -448,6 +450,8 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PortDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -686,7 +690,7 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -707,7 +711,7 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs
index 2b06f7d45..b5f047cd3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs
@@ -88,7 +88,7 @@ public class PortUsageReader : XmiDataReader<IPortUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public PortUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public PortUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PortUsageReader>.Instance : loggerFactory.CreateLogger<PortUsageReader>();
         }
@@ -134,6 +134,8 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PortUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -558,7 +560,7 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -579,7 +581,7 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -648,6 +650,8 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "PortUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1072,7 +1076,7 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1093,7 +1097,7 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs
index 2c792dda1..2fa1214bc 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs
@@ -65,7 +65,7 @@ public class PredicateReader : XmiDataReader<IPredicate>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public PredicateReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public PredicateReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PredicateReader>.Instance : loggerFactory.CreateLogger<PredicateReader>();
         }
@@ -111,6 +111,8 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Predicate", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -305,7 +307,7 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -326,7 +328,7 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -383,6 +385,8 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Predicate", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -577,7 +581,7 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -598,7 +602,7 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs
index c4214289e..0e3ec10f4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs
@@ -62,7 +62,7 @@ public class RedefinitionReader : XmiDataReader<IRedefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public RedefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public RedefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RedefinitionReader>.Instance : loggerFactory.CreateLogger<RedefinitionReader>();
         }
@@ -108,6 +108,8 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Redefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -330,7 +332,7 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -351,7 +353,7 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -372,7 +374,7 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -393,7 +395,7 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -414,7 +416,7 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var redefinedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var redefinedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.RedefinedFeature = redefinedFeatureValue;
                                     }
@@ -435,7 +437,7 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var redefiningFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var redefiningFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.RedefiningFeature = redefiningFeatureValue;
                                     }
@@ -492,6 +494,8 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Redefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -714,7 +718,7 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -735,7 +739,7 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -756,7 +760,7 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -777,7 +781,7 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -798,7 +802,7 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var redefinedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var redefinedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.RedefinedFeature = redefinedFeatureValue;
                                     }
@@ -819,7 +823,7 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var redefiningFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var redefiningFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.RedefiningFeature = redefiningFeatureValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs
index 76d4b283b..2485b6cdc 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs
@@ -62,7 +62,7 @@ public class ReferenceSubsettingReader : XmiDataReader<IReferenceSubsetting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ReferenceSubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ReferenceSubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ReferenceSubsettingReader>.Instance : loggerFactory.CreateLogger<ReferenceSubsettingReader>();
         }
@@ -108,6 +108,8 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ReferenceSubsetting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -320,7 +322,7 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -341,7 +343,7 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -362,7 +364,7 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -383,7 +385,7 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -404,7 +406,7 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var referencedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var referencedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ReferencedFeature = referencedFeatureValue;
                                     }
@@ -461,6 +463,8 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ReferenceSubsetting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -673,7 +677,7 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -694,7 +698,7 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -715,7 +719,7 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -736,7 +740,7 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -757,7 +761,7 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var referencedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var referencedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ReferencedFeature = referencedFeatureValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs
index baa9bd486..942dd75d2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs
@@ -86,7 +86,7 @@ public class ReferenceUsageReader : XmiDataReader<IReferenceUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ReferenceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ReferenceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ReferenceUsageReader>.Instance : loggerFactory.CreateLogger<ReferenceUsageReader>();
         }
@@ -132,6 +132,8 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ReferenceUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -524,7 +526,7 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -545,7 +547,7 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -602,6 +604,8 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ReferenceUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -994,7 +998,7 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1015,7 +1019,7 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs
index 82678661d..c13d82102 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs
@@ -85,7 +85,7 @@ public class RenderingDefinitionReader : XmiDataReader<IRenderingDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public RenderingDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public RenderingDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RenderingDefinitionReader>.Instance : loggerFactory.CreateLogger<RenderingDefinitionReader>();
         }
@@ -131,6 +131,8 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RenderingDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -369,7 +371,7 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -390,7 +392,7 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -447,6 +449,8 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RenderingDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -685,7 +689,7 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -706,7 +710,7 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs
index ba26737ee..c2b8babf4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs
@@ -89,7 +89,7 @@ public class RenderingUsageReader : XmiDataReader<IRenderingUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public RenderingUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public RenderingUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RenderingUsageReader>.Instance : loggerFactory.CreateLogger<RenderingUsageReader>();
         }
@@ -135,6 +135,8 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RenderingUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -559,7 +561,7 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -580,7 +582,7 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -649,6 +651,8 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RenderingUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1073,7 +1077,7 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1094,7 +1098,7 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs
index 4e2faca30..35b41e78e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs
@@ -66,7 +66,7 @@ public class RequirementConstraintMembershipReader : XmiDataReader<IRequirementC
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public RequirementConstraintMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public RequirementConstraintMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RequirementConstraintMembershipReader>.Instance : loggerFactory.CreateLogger<RequirementConstraintMembershipReader>();
         }
@@ -112,6 +112,8 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RequirementConstraintMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -346,7 +348,7 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -367,7 +369,7 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -388,7 +390,7 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -409,7 +411,7 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -478,6 +480,8 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RequirementConstraintMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -712,7 +716,7 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -733,7 +737,7 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -754,7 +758,7 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -775,7 +779,7 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs
index 50062fe29..49a49c969 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs
@@ -87,7 +87,7 @@ public class RequirementDefinitionReader : XmiDataReader<IRequirementDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public RequirementDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public RequirementDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RequirementDefinitionReader>.Instance : loggerFactory.CreateLogger<RequirementDefinitionReader>();
         }
@@ -133,6 +133,8 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RequirementDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -359,7 +361,7 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -380,7 +382,7 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -449,6 +451,8 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RequirementDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -675,7 +679,7 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -696,7 +700,7 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs
index 1d7fbe4d0..c1c955215 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs
@@ -90,7 +90,7 @@ public class RequirementUsageReader : XmiDataReader<IRequirementUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public RequirementUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public RequirementUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RequirementUsageReader>.Instance : loggerFactory.CreateLogger<RequirementUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RequirementUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -548,7 +550,7 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -569,7 +571,7 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RequirementUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1062,7 +1066,7 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1083,7 +1087,7 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs
index 508ec542c..a494efa22 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs
@@ -67,7 +67,7 @@ public class RequirementVerificationMembershipReader : XmiDataReader<IRequiremen
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public RequirementVerificationMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public RequirementVerificationMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RequirementVerificationMembershipReader>.Instance : loggerFactory.CreateLogger<RequirementVerificationMembershipReader>();
         }
@@ -113,6 +113,8 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RequirementVerificationMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -347,7 +349,7 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -368,7 +370,7 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -389,7 +391,7 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -410,7 +412,7 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -479,6 +481,8 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RequirementVerificationMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -713,7 +717,7 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -734,7 +738,7 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -755,7 +759,7 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -776,7 +780,7 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs
index 58df252ca..0f5f6b317 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs
@@ -64,7 +64,7 @@ public class ResultExpressionMembershipReader : XmiDataReader<IResultExpressionM
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ResultExpressionMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ResultExpressionMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ResultExpressionMembershipReader>.Instance : loggerFactory.CreateLogger<ResultExpressionMembershipReader>();
         }
@@ -110,6 +110,8 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ResultExpressionMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -322,7 +324,7 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -343,7 +345,7 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -364,7 +366,7 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -385,7 +387,7 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -454,6 +456,8 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ResultExpressionMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -666,7 +670,7 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -687,7 +691,7 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -708,7 +712,7 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -729,7 +733,7 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs
index fef0ea8b6..6a9c96fe6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs
@@ -65,7 +65,7 @@ public class ReturnParameterMembershipReader : XmiDataReader<IReturnParameterMem
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ReturnParameterMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ReturnParameterMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ReturnParameterMembershipReader>.Instance : loggerFactory.CreateLogger<ReturnParameterMembershipReader>();
         }
@@ -111,6 +111,8 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ReturnParameterMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -323,7 +325,7 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -344,7 +346,7 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -365,7 +367,7 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -386,7 +388,7 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -455,6 +457,8 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ReturnParameterMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -667,7 +671,7 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -688,7 +692,7 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -709,7 +713,7 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -730,7 +734,7 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs
index ccfc054bf..5c4937331 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs
@@ -90,7 +90,7 @@ public class SatisfyRequirementUsageReader : XmiDataReader<ISatisfyRequirementUs
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SatisfyRequirementUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SatisfyRequirementUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SatisfyRequirementUsageReader>.Instance : loggerFactory.CreateLogger<SatisfyRequirementUsageReader>();
         }
@@ -136,6 +136,8 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SatisfyRequirementUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -570,7 +572,7 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -591,7 +593,7 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -672,6 +674,8 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SatisfyRequirementUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1106,7 +1110,7 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1127,7 +1131,7 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs
index b8859ceea..5df7f8914 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs
@@ -66,7 +66,7 @@ public class SelectExpressionReader : XmiDataReader<ISelectExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SelectExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SelectExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SelectExpressionReader>.Instance : loggerFactory.CreateLogger<SelectExpressionReader>();
         }
@@ -112,6 +112,8 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SelectExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -523,7 +525,7 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -544,7 +546,7 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -601,6 +603,8 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SelectExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1012,7 +1016,7 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1033,7 +1037,7 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs
index 2abb0b9a2..e612b0c4b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs
@@ -90,7 +90,7 @@ public class SendActionUsageReader : XmiDataReader<ISendActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SendActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SendActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SendActionUsageReader>.Instance : loggerFactory.CreateLogger<SendActionUsageReader>();
         }
@@ -136,6 +136,8 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SendActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SendActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs
index 174b5f84b..a0b16603c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs
@@ -61,7 +61,7 @@ public class SpecializationReader : XmiDataReader<ISpecialization>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SpecializationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SpecializationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SpecializationReader>.Instance : loggerFactory.CreateLogger<SpecializationReader>();
         }
@@ -107,6 +107,8 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Specialization", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -305,7 +307,7 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var generalValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var generalValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.General = generalValue;
                                     }
@@ -350,7 +352,7 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -371,7 +373,7 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -392,7 +394,7 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -413,7 +415,7 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -434,7 +436,7 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var specificValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var specificValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Specific = specificValue;
                                     }
@@ -491,6 +493,8 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Specialization", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -689,7 +693,7 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var generalValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var generalValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.General = generalValue;
                                     }
@@ -734,7 +738,7 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -755,7 +759,7 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -776,7 +780,7 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -797,7 +801,7 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -818,7 +822,7 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var specificValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var specificValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Specific = specificValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs
index 4d02154db..ce4831175 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs
@@ -66,7 +66,7 @@ public class StakeholderMembershipReader : XmiDataReader<IStakeholderMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public StakeholderMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public StakeholderMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StakeholderMembershipReader>.Instance : loggerFactory.CreateLogger<StakeholderMembershipReader>();
         }
@@ -112,6 +112,8 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "StakeholderMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -324,7 +326,7 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -345,7 +347,7 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -366,7 +368,7 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -387,7 +389,7 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -456,6 +458,8 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "StakeholderMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -668,7 +672,7 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -689,7 +693,7 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -710,7 +714,7 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -731,7 +735,7 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs
index a225dd9a3..8e280f8a9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs
@@ -86,7 +86,7 @@ public class StateDefinitionReader : XmiDataReader<IStateDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public StateDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public StateDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StateDefinitionReader>.Instance : loggerFactory.CreateLogger<StateDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "StateDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -392,7 +394,7 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -413,7 +415,7 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -470,6 +472,8 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "StateDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -730,7 +734,7 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -751,7 +755,7 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs
index 32412b6ce..4f44ca63d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs
@@ -66,7 +66,7 @@ public class StateSubactionMembershipReader : XmiDataReader<IStateSubactionMembe
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public StateSubactionMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public StateSubactionMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StateSubactionMembershipReader>.Instance : loggerFactory.CreateLogger<StateSubactionMembershipReader>();
         }
@@ -112,6 +112,8 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "StateSubactionMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -346,7 +348,7 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -367,7 +369,7 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -388,7 +390,7 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -409,7 +411,7 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -478,6 +480,8 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "StateSubactionMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -712,7 +716,7 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -733,7 +737,7 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -754,7 +758,7 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -775,7 +779,7 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs
index 97c2fdddf..a820b8387 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs
@@ -89,7 +89,7 @@ public class StateUsageReader : XmiDataReader<IStateUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public StateUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public StateUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StateUsageReader>.Instance : loggerFactory.CreateLogger<StateUsageReader>();
         }
@@ -135,6 +135,8 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "StateUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -581,7 +583,7 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -602,7 +604,7 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -671,6 +673,8 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "StateUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1117,7 +1121,7 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1138,7 +1142,7 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs
index dc74613c9..3269930e8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs
@@ -64,7 +64,7 @@ public class StepReader : XmiDataReader<IStep>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public StepReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public StepReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StepReader>.Instance : loggerFactory.CreateLogger<StepReader>();
         }
@@ -110,6 +110,8 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Step", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -502,7 +504,7 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -523,7 +525,7 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -580,6 +582,8 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Step", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -972,7 +976,7 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -993,7 +997,7 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs
index fd2bf85e6..fdead9644 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs
@@ -65,7 +65,7 @@ public class StructureReader : XmiDataReader<IStructure>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public StructureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public StructureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StructureReader>.Instance : loggerFactory.CreateLogger<StructureReader>();
         }
@@ -111,6 +111,8 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Structure", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -305,7 +307,7 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -326,7 +328,7 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -383,6 +385,8 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Structure", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -577,7 +581,7 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -598,7 +602,7 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs
index 5b4418ba0..b31689e64 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs
@@ -62,7 +62,7 @@ public class SubclassificationReader : XmiDataReader<ISubclassification>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SubclassificationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SubclassificationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SubclassificationReader>.Instance : loggerFactory.CreateLogger<SubclassificationReader>();
         }
@@ -108,6 +108,8 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Subclassification", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -330,7 +332,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -351,7 +353,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -372,7 +374,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -393,7 +395,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -414,7 +416,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var subclassifierValue = (IClassifier)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var subclassifierValue = (IClassifier)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Subclassifier = subclassifierValue;
                                     }
@@ -435,7 +437,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var superclassifierValue = (IClassifier)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var superclassifierValue = (IClassifier)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Superclassifier = superclassifierValue;
                                     }
@@ -492,6 +494,8 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Subclassification", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -714,7 +718,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -735,7 +739,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -756,7 +760,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -777,7 +781,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -798,7 +802,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var subclassifierValue = (IClassifier)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var subclassifierValue = (IClassifier)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Subclassifier = subclassifierValue;
                                     }
@@ -819,7 +823,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var superclassifierValue = (IClassifier)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var superclassifierValue = (IClassifier)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Superclassifier = superclassifierValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs
index 18008a8af..75b265573 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs
@@ -66,7 +66,7 @@ public class SubjectMembershipReader : XmiDataReader<ISubjectMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SubjectMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SubjectMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SubjectMembershipReader>.Instance : loggerFactory.CreateLogger<SubjectMembershipReader>();
         }
@@ -112,6 +112,8 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SubjectMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -324,7 +326,7 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -345,7 +347,7 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -366,7 +368,7 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -387,7 +389,7 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -456,6 +458,8 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SubjectMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -668,7 +672,7 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -689,7 +693,7 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -710,7 +714,7 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -731,7 +735,7 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs
index e792edb14..84ba820da 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs
@@ -62,7 +62,7 @@ public class SubsettingReader : XmiDataReader<ISubsetting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SubsettingReader>.Instance : loggerFactory.CreateLogger<SubsettingReader>();
         }
@@ -108,6 +108,8 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Subsetting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -330,7 +332,7 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -351,7 +353,7 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -372,7 +374,7 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -393,7 +395,7 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -414,7 +416,7 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var subsettedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var subsettedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.SubsettedFeature = subsettedFeatureValue;
                                     }
@@ -435,7 +437,7 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var subsettingFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var subsettingFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.SubsettingFeature = subsettingFeatureValue;
                                     }
@@ -492,6 +494,8 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Subsetting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -714,7 +718,7 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -735,7 +739,7 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -756,7 +760,7 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -777,7 +781,7 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -798,7 +802,7 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var subsettedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var subsettedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.SubsettedFeature = subsettedFeatureValue;
                                     }
@@ -819,7 +823,7 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var subsettingFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var subsettingFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.SubsettingFeature = subsettingFeatureValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs
index 5cba6cda6..b631760d7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs
@@ -88,7 +88,7 @@ public class SuccessionAsUsageReader : XmiDataReader<ISuccessionAsUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SuccessionAsUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SuccessionAsUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SuccessionAsUsageReader>.Instance : loggerFactory.CreateLogger<SuccessionAsUsageReader>();
         }
@@ -134,6 +134,8 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SuccessionAsUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -578,7 +580,7 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -599,7 +601,7 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -620,7 +622,7 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -641,7 +643,7 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -698,6 +700,8 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SuccessionAsUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1142,7 +1146,7 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1163,7 +1167,7 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1184,7 +1188,7 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1205,7 +1209,7 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs
index 2bec6f31e..35089b1d4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs
@@ -68,7 +68,7 @@ public class SuccessionFlowReader : XmiDataReader<ISuccessionFlow>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SuccessionFlowReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SuccessionFlowReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SuccessionFlowReader>.Instance : loggerFactory.CreateLogger<SuccessionFlowReader>();
         }
@@ -114,6 +114,8 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SuccessionFlow", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -558,7 +560,7 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -579,7 +581,7 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -600,7 +602,7 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -621,7 +623,7 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -678,6 +680,8 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SuccessionFlow", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1122,7 +1126,7 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1143,7 +1147,7 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1164,7 +1168,7 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1185,7 +1189,7 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs
index e6afa8660..af918d310 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs
@@ -92,7 +92,7 @@ public class SuccessionFlowUsageReader : XmiDataReader<ISuccessionFlowUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SuccessionFlowUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SuccessionFlowUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SuccessionFlowUsageReader>.Instance : loggerFactory.CreateLogger<SuccessionFlowUsageReader>();
         }
@@ -138,6 +138,8 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SuccessionFlowUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -614,7 +616,7 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -635,7 +637,7 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -656,7 +658,7 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -677,7 +679,7 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -746,6 +748,8 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SuccessionFlowUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1222,7 +1226,7 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1243,7 +1247,7 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1264,7 +1268,7 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1285,7 +1289,7 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs
index 1e55cf9e8..b811568cd 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs
@@ -65,7 +65,7 @@ public class SuccessionReader : XmiDataReader<ISuccession>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SuccessionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public SuccessionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SuccessionReader>.Instance : loggerFactory.CreateLogger<SuccessionReader>();
         }
@@ -111,6 +111,8 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Succession", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -555,7 +557,7 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -576,7 +578,7 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -597,7 +599,7 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -618,7 +620,7 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -675,6 +677,8 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Succession", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1119,7 +1123,7 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1140,7 +1144,7 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1161,7 +1165,7 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1182,7 +1186,7 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs
index bcd5f20d6..27785728d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs
@@ -90,7 +90,7 @@ public class TerminateActionUsageReader : XmiDataReader<ITerminateActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public TerminateActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public TerminateActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TerminateActionUsageReader>.Instance : loggerFactory.CreateLogger<TerminateActionUsageReader>();
         }
@@ -136,6 +136,8 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TerminateActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TerminateActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs
index 6916876ad..e5c789080 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs
@@ -60,7 +60,7 @@ public class TextualRepresentationReader : XmiDataReader<ITextualRepresentation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public TextualRepresentationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public TextualRepresentationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TextualRepresentationReader>.Instance : loggerFactory.CreateLogger<TextualRepresentationReader>();
         }
@@ -106,6 +106,8 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TextualRepresentation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -294,7 +296,7 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -315,7 +317,7 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -372,6 +374,8 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TextualRepresentation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +564,7 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +585,7 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs
index 56496b3f9..f2a2fa7e5 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs
@@ -66,7 +66,7 @@ public class TransitionFeatureMembershipReader : XmiDataReader<ITransitionFeatur
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public TransitionFeatureMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public TransitionFeatureMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TransitionFeatureMembershipReader>.Instance : loggerFactory.CreateLogger<TransitionFeatureMembershipReader>();
         }
@@ -112,6 +112,8 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TransitionFeatureMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -346,7 +348,7 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -367,7 +369,7 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -388,7 +390,7 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -409,7 +411,7 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -478,6 +480,8 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TransitionFeatureMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -712,7 +716,7 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -733,7 +737,7 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -754,7 +758,7 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -775,7 +779,7 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs
index 1ae1e0dcb..68bca9727 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs
@@ -91,7 +91,7 @@ public class TransitionUsageReader : XmiDataReader<ITransitionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public TransitionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public TransitionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TransitionUsageReader>.Instance : loggerFactory.CreateLogger<TransitionUsageReader>();
         }
@@ -137,6 +137,8 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TransitionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -561,7 +563,7 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -582,7 +584,7 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -651,6 +653,8 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TransitionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1075,7 +1079,7 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1096,7 +1100,7 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs
index 3f347c4a2..ac432b068 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs
@@ -68,7 +68,7 @@ public class TriggerInvocationExpressionReader : XmiDataReader<ITriggerInvocatio
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public TriggerInvocationExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public TriggerInvocationExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TriggerInvocationExpressionReader>.Instance : loggerFactory.CreateLogger<TriggerInvocationExpressionReader>();
         }
@@ -114,6 +114,8 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TriggerInvocationExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -528,7 +530,7 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -549,7 +551,7 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -606,6 +608,8 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TriggerInvocationExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1020,7 +1024,7 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1041,7 +1045,7 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs
index 01cfae493..3bb5d01d6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs
@@ -62,7 +62,7 @@ public class TypeFeaturingReader : XmiDataReader<ITypeFeaturing>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public TypeFeaturingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public TypeFeaturingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TypeFeaturingReader>.Instance : loggerFactory.CreateLogger<TypeFeaturingReader>();
         }
@@ -108,6 +108,8 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TypeFeaturing", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -306,7 +308,7 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var featureOfTypeValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var featureOfTypeValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.FeatureOfType = featureOfTypeValue;
                                     }
@@ -327,7 +329,7 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var featuringTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var featuringTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.FeaturingType = featuringTypeValue;
                                     }
@@ -372,7 +374,7 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -393,7 +395,7 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -414,7 +416,7 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -435,7 +437,7 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -492,6 +494,8 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TypeFeaturing", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -690,7 +694,7 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var featureOfTypeValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var featureOfTypeValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.FeatureOfType = featureOfTypeValue;
                                     }
@@ -711,7 +715,7 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var featuringTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var featuringTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.FeaturingType = featuringTypeValue;
                                     }
@@ -756,7 +760,7 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -777,7 +781,7 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -798,7 +802,7 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -819,7 +823,7 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs
index db0fd0dbb..468f47790 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs
@@ -62,7 +62,7 @@ public class TypeReader : XmiDataReader<IType>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public TypeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public TypeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TypeReader>.Instance : loggerFactory.CreateLogger<TypeReader>();
         }
@@ -108,6 +108,8 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Type", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -302,7 +304,7 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -323,7 +325,7 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -380,6 +382,8 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Type", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -574,7 +578,7 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -595,7 +599,7 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs
index c7e4f894e..2b5af708b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs
@@ -61,7 +61,7 @@ public class UnioningReader : XmiDataReader<IUnioning>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public UnioningReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public UnioningReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<UnioningReader>.Instance : loggerFactory.CreateLogger<UnioningReader>();
         }
@@ -107,6 +107,8 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Unioning", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -319,7 +321,7 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -340,7 +342,7 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -361,7 +363,7 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -382,7 +384,7 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -403,7 +405,7 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var unioningTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var unioningTypeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.UnioningType = unioningTypeValue;
                                     }
@@ -460,6 +462,8 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Unioning", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -672,7 +676,7 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -693,7 +697,7 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -714,7 +718,7 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -735,7 +739,7 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -756,7 +760,7 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     }
                                     else
                                     {
-                                        var unioningTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var unioningTypeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.UnioningType = unioningTypeValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs
index 865b63a25..6ebda1fe8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs
@@ -86,7 +86,7 @@ public class UsageReader : XmiDataReader<IUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public UsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public UsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<UsageReader>.Instance : loggerFactory.CreateLogger<UsageReader>();
         }
@@ -132,6 +132,8 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Usage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -524,7 +526,7 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -545,7 +547,7 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -602,6 +604,8 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Usage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -994,7 +998,7 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1015,7 +1019,7 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs
index 1798abe05..a4772d718 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs
@@ -87,7 +87,7 @@ public class UseCaseDefinitionReader : XmiDataReader<IUseCaseDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public UseCaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public UseCaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<UseCaseDefinitionReader>.Instance : loggerFactory.CreateLogger<UseCaseDefinitionReader>();
         }
@@ -133,6 +133,8 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "UseCaseDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -371,7 +373,7 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -392,7 +394,7 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -449,6 +451,8 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "UseCaseDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -687,7 +691,7 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -708,7 +712,7 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs
index a3c5ccf7d..be0172fbe 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs
@@ -90,7 +90,7 @@ public class UseCaseUsageReader : XmiDataReader<IUseCaseUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public UseCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public UseCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<UseCaseUsageReader>.Instance : loggerFactory.CreateLogger<UseCaseUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "UseCaseUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "UseCaseUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs
index e11f62813..0c9183d87 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs
@@ -62,7 +62,7 @@ public class VariantMembershipReader : XmiDataReader<IVariantMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public VariantMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public VariantMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<VariantMembershipReader>.Instance : loggerFactory.CreateLogger<VariantMembershipReader>();
         }
@@ -108,6 +108,8 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "VariantMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -320,7 +322,7 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -341,7 +343,7 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -362,7 +364,7 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -383,7 +385,7 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -452,6 +454,8 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "VariantMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -664,7 +668,7 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -685,7 +689,7 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -706,7 +710,7 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -727,7 +731,7 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs
index d66274707..bc2803928 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs
@@ -87,7 +87,7 @@ public class VerificationCaseDefinitionReader : XmiDataReader<IVerificationCaseD
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public VerificationCaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public VerificationCaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<VerificationCaseDefinitionReader>.Instance : loggerFactory.CreateLogger<VerificationCaseDefinitionReader>();
         }
@@ -133,6 +133,8 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "VerificationCaseDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -371,7 +373,7 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -392,7 +394,7 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -449,6 +451,8 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "VerificationCaseDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -687,7 +691,7 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -708,7 +712,7 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs
index 4530f24c2..5a0696ab6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs
@@ -90,7 +90,7 @@ public class VerificationCaseUsageReader : XmiDataReader<IVerificationCaseUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public VerificationCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public VerificationCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<VerificationCaseUsageReader>.Instance : loggerFactory.CreateLogger<VerificationCaseUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "VerificationCaseUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "VerificationCaseUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs
index 3e601b92c..c83c98107 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs
@@ -86,7 +86,7 @@ public class ViewDefinitionReader : XmiDataReader<IViewDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ViewDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ViewDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ViewDefinitionReader>.Instance : loggerFactory.CreateLogger<ViewDefinitionReader>();
         }
@@ -132,6 +132,8 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ViewDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -370,7 +372,7 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -391,7 +393,7 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -448,6 +450,8 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ViewDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -686,7 +690,7 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -707,7 +711,7 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs
index 4dcdbf570..373b13f00 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs
@@ -64,7 +64,7 @@ public class ViewRenderingMembershipReader : XmiDataReader<IViewRenderingMembers
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ViewRenderingMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ViewRenderingMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ViewRenderingMembershipReader>.Instance : loggerFactory.CreateLogger<ViewRenderingMembershipReader>();
         }
@@ -110,6 +110,8 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ViewRenderingMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -322,7 +324,7 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -343,7 +345,7 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -364,7 +366,7 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -385,7 +387,7 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -454,6 +456,8 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ViewRenderingMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -666,7 +670,7 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -687,7 +691,7 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -708,7 +712,7 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -729,7 +733,7 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs
index b1455282f..adf2753b0 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs
@@ -90,7 +90,7 @@ public class ViewUsageReader : XmiDataReader<IViewUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ViewUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ViewUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ViewUsageReader>.Instance : loggerFactory.CreateLogger<ViewUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ViewUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ViewUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs
index 3ae0c84df..03eda3e79 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs
@@ -87,7 +87,7 @@ public class ViewpointDefinitionReader : XmiDataReader<IViewpointDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ViewpointDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ViewpointDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ViewpointDefinitionReader>.Instance : loggerFactory.CreateLogger<ViewpointDefinitionReader>();
         }
@@ -133,6 +133,8 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ViewpointDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -359,7 +361,7 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -380,7 +382,7 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -449,6 +451,8 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ViewpointDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -675,7 +679,7 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -696,7 +700,7 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs
index f963fc233..b9fbaff32 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs
@@ -90,7 +90,7 @@ public class ViewpointUsageReader : XmiDataReader<IViewpointUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ViewpointUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public ViewpointUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ViewpointUsageReader>.Instance : loggerFactory.CreateLogger<ViewpointUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ViewpointUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -548,7 +550,7 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -569,7 +571,7 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ViewpointUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1062,7 +1066,7 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1083,7 +1087,7 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs
index 3c74d4f4c..209690a1c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs
@@ -90,7 +90,7 @@ public class WhileLoopActionUsageReader : XmiDataReader<IWhileLoopActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public WhileLoopActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        public WhileLoopActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<WhileLoopActionUsageReader>.Instance : loggerFactory.CreateLogger<WhileLoopActionUsageReader>();
         }
@@ -136,6 +136,8 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "WhileLoopActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -560,7 +562,7 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -581,7 +583,7 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -650,6 +652,8 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "WhileLoopActionUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1074,7 +1078,7 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1095,7 +1099,7 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/XmiDataReaderFacade.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/XmiDataReaderFacade.cs
index c34da7c54..aef36854c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/XmiDataReaderFacade.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/XmiDataReaderFacade.cs
@@ -44,2027 +44,2027 @@ public class XmiDataReaderFacade : IXmiDataReaderFacade
         /// A dictionary that contains functions that return <see cref="IData"/> based a key that represents the xsi Type
         /// and a provided <see cref="IXmiDataCache"/>, <see cref="IExternalReferenceService" />, <see cref="ILoggerFactory"/> and <see cref="XmlReader"/>
         /// </summary>
-        private readonly Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IData>> readerCache;
+        private readonly Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IXmiElementOriginMap, IData>> readerCache;
 
         /// <summary>
         /// A dictionary that contains functions that return an awaitable <see cref="Task" /> with the <see cref="IData"/> based a key that represents the xsi Type
         /// and a provided <see cref="IXmiDataCache"/>, <see cref="IExternalReferenceService" />, <see cref="ILoggerFactory"/> and <see cref="XmlReader"/>
         /// </summary>
-        private readonly Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, Task<IData>>> readerAsyncCache;
+        private readonly Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IXmiElementOriginMap, Task<IData>>> readerAsyncCache;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="XmiDataReaderFacade"/>
         /// </summary>
         public XmiDataReaderFacade()
         {
-            this.readerCache = new Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IData>>
+            this.readerCache = new Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IXmiElementOriginMap, IData>>
             {
-                ["sysml:AcceptActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AcceptActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var acceptActionUsageReader = new AcceptActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var acceptActionUsageReader = new AcceptActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return acceptActionUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ActionDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ActionDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var actionDefinitionReader = new ActionDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var actionDefinitionReader = new ActionDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return actionDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var actionUsageReader = new ActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var actionUsageReader = new ActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return actionUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ActorMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ActorMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var actorMembershipReader = new ActorMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var actorMembershipReader = new ActorMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return actorMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:AllocationDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AllocationDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var allocationDefinitionReader = new AllocationDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var allocationDefinitionReader = new AllocationDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return allocationDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:AllocationUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AllocationUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var allocationUsageReader = new AllocationUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var allocationUsageReader = new AllocationUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return allocationUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:AnalysisCaseDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AnalysisCaseDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var analysisCaseDefinitionReader = new AnalysisCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var analysisCaseDefinitionReader = new AnalysisCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return analysisCaseDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:AnalysisCaseUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AnalysisCaseUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var analysisCaseUsageReader = new AnalysisCaseUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var analysisCaseUsageReader = new AnalysisCaseUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return analysisCaseUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:AnnotatingElement"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AnnotatingElement"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var annotatingElementReader = new AnnotatingElementReader(cache, this, externalReferenceService, loggerFactory);
+                    var annotatingElementReader = new AnnotatingElementReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return annotatingElementReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Annotation"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Annotation"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var annotationReader = new AnnotationReader(cache, this, externalReferenceService, loggerFactory);
+                    var annotationReader = new AnnotationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return annotationReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:AssertConstraintUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AssertConstraintUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var assertConstraintUsageReader = new AssertConstraintUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var assertConstraintUsageReader = new AssertConstraintUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return assertConstraintUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:AssignmentActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AssignmentActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var assignmentActionUsageReader = new AssignmentActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var assignmentActionUsageReader = new AssignmentActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return assignmentActionUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Association"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Association"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var associationReader = new AssociationReader(cache, this, externalReferenceService, loggerFactory);
+                    var associationReader = new AssociationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return associationReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:AssociationStructure"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AssociationStructure"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var associationStructureReader = new AssociationStructureReader(cache, this, externalReferenceService, loggerFactory);
+                    var associationStructureReader = new AssociationStructureReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return associationStructureReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:AttributeDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AttributeDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var attributeDefinitionReader = new AttributeDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var attributeDefinitionReader = new AttributeDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return attributeDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:AttributeUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AttributeUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var attributeUsageReader = new AttributeUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var attributeUsageReader = new AttributeUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return attributeUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Behavior"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Behavior"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var behaviorReader = new BehaviorReader(cache, this, externalReferenceService, loggerFactory);
+                    var behaviorReader = new BehaviorReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return behaviorReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:BindingConnector"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:BindingConnector"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var bindingConnectorReader = new BindingConnectorReader(cache, this, externalReferenceService, loggerFactory);
+                    var bindingConnectorReader = new BindingConnectorReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return bindingConnectorReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:BindingConnectorAsUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:BindingConnectorAsUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var bindingConnectorAsUsageReader = new BindingConnectorAsUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var bindingConnectorAsUsageReader = new BindingConnectorAsUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return bindingConnectorAsUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:BooleanExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:BooleanExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var booleanExpressionReader = new BooleanExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var booleanExpressionReader = new BooleanExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return booleanExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:CalculationDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CalculationDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var calculationDefinitionReader = new CalculationDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var calculationDefinitionReader = new CalculationDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return calculationDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:CalculationUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CalculationUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var calculationUsageReader = new CalculationUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var calculationUsageReader = new CalculationUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return calculationUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:CaseDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CaseDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var caseDefinitionReader = new CaseDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var caseDefinitionReader = new CaseDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return caseDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:CaseUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CaseUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var caseUsageReader = new CaseUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var caseUsageReader = new CaseUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return caseUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Class"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Class"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var classReader = new ClassReader(cache, this, externalReferenceService, loggerFactory);
+                    var classReader = new ClassReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return classReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Classifier"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Classifier"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var classifierReader = new ClassifierReader(cache, this, externalReferenceService, loggerFactory);
+                    var classifierReader = new ClassifierReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return classifierReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:CollectExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CollectExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var collectExpressionReader = new CollectExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var collectExpressionReader = new CollectExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return collectExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Comment"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Comment"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var commentReader = new CommentReader(cache, this, externalReferenceService, loggerFactory);
+                    var commentReader = new CommentReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return commentReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ConcernDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConcernDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var concernDefinitionReader = new ConcernDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var concernDefinitionReader = new ConcernDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return concernDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ConcernUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConcernUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var concernUsageReader = new ConcernUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var concernUsageReader = new ConcernUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return concernUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ConjugatedPortDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConjugatedPortDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var conjugatedPortDefinitionReader = new ConjugatedPortDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var conjugatedPortDefinitionReader = new ConjugatedPortDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return conjugatedPortDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ConjugatedPortTyping"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConjugatedPortTyping"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var conjugatedPortTypingReader = new ConjugatedPortTypingReader(cache, this, externalReferenceService, loggerFactory);
+                    var conjugatedPortTypingReader = new ConjugatedPortTypingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return conjugatedPortTypingReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Conjugation"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Conjugation"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var conjugationReader = new ConjugationReader(cache, this, externalReferenceService, loggerFactory);
+                    var conjugationReader = new ConjugationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return conjugationReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ConnectionDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConnectionDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var connectionDefinitionReader = new ConnectionDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var connectionDefinitionReader = new ConnectionDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return connectionDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ConnectionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConnectionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var connectionUsageReader = new ConnectionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var connectionUsageReader = new ConnectionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return connectionUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Connector"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Connector"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var connectorReader = new ConnectorReader(cache, this, externalReferenceService, loggerFactory);
+                    var connectorReader = new ConnectorReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return connectorReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ConstraintDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConstraintDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var constraintDefinitionReader = new ConstraintDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var constraintDefinitionReader = new ConstraintDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return constraintDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ConstraintUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConstraintUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var constraintUsageReader = new ConstraintUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var constraintUsageReader = new ConstraintUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return constraintUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ConstructorExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConstructorExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var constructorExpressionReader = new ConstructorExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var constructorExpressionReader = new ConstructorExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return constructorExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:CrossSubsetting"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CrossSubsetting"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var crossSubsettingReader = new CrossSubsettingReader(cache, this, externalReferenceService, loggerFactory);
+                    var crossSubsettingReader = new CrossSubsettingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return crossSubsettingReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:DataType"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:DataType"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var dataTypeReader = new DataTypeReader(cache, this, externalReferenceService, loggerFactory);
+                    var dataTypeReader = new DataTypeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return dataTypeReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:DecisionNode"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:DecisionNode"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var decisionNodeReader = new DecisionNodeReader(cache, this, externalReferenceService, loggerFactory);
+                    var decisionNodeReader = new DecisionNodeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return decisionNodeReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Definition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Definition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var definitionReader = new DefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var definitionReader = new DefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return definitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Dependency"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Dependency"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var dependencyReader = new DependencyReader(cache, this, externalReferenceService, loggerFactory);
+                    var dependencyReader = new DependencyReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return dependencyReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Differencing"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Differencing"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var differencingReader = new DifferencingReader(cache, this, externalReferenceService, loggerFactory);
+                    var differencingReader = new DifferencingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return differencingReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Disjoining"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Disjoining"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var disjoiningReader = new DisjoiningReader(cache, this, externalReferenceService, loggerFactory);
+                    var disjoiningReader = new DisjoiningReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return disjoiningReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Documentation"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Documentation"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var documentationReader = new DocumentationReader(cache, this, externalReferenceService, loggerFactory);
+                    var documentationReader = new DocumentationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return documentationReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ElementFilterMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ElementFilterMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var elementFilterMembershipReader = new ElementFilterMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var elementFilterMembershipReader = new ElementFilterMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return elementFilterMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:EndFeatureMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:EndFeatureMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var endFeatureMembershipReader = new EndFeatureMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var endFeatureMembershipReader = new EndFeatureMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return endFeatureMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:EnumerationDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:EnumerationDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var enumerationDefinitionReader = new EnumerationDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var enumerationDefinitionReader = new EnumerationDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return enumerationDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:EnumerationUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:EnumerationUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var enumerationUsageReader = new EnumerationUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var enumerationUsageReader = new EnumerationUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return enumerationUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:EventOccurrenceUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:EventOccurrenceUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var eventOccurrenceUsageReader = new EventOccurrenceUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var eventOccurrenceUsageReader = new EventOccurrenceUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return eventOccurrenceUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ExhibitStateUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ExhibitStateUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var exhibitStateUsageReader = new ExhibitStateUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var exhibitStateUsageReader = new ExhibitStateUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return exhibitStateUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Expression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Expression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var expressionReader = new ExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var expressionReader = new ExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return expressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Feature"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Feature"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureReader = new FeatureReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureReader = new FeatureReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return featureReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureChainExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureChainExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureChainExpressionReader = new FeatureChainExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureChainExpressionReader = new FeatureChainExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return featureChainExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureChaining"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureChaining"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureChainingReader = new FeatureChainingReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureChainingReader = new FeatureChainingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return featureChainingReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureInverting"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureInverting"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureInvertingReader = new FeatureInvertingReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureInvertingReader = new FeatureInvertingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return featureInvertingReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureMembershipReader = new FeatureMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureMembershipReader = new FeatureMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return featureMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureReferenceExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureReferenceExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureReferenceExpressionReader = new FeatureReferenceExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureReferenceExpressionReader = new FeatureReferenceExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return featureReferenceExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureTyping"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureTyping"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureTypingReader = new FeatureTypingReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureTypingReader = new FeatureTypingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return featureTypingReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureValue"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureValue"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureValueReader = new FeatureValueReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureValueReader = new FeatureValueReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return featureValueReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Flow"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Flow"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var flowReader = new FlowReader(cache, this, externalReferenceService, loggerFactory);
+                    var flowReader = new FlowReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return flowReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FlowDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FlowDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var flowDefinitionReader = new FlowDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var flowDefinitionReader = new FlowDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return flowDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FlowEnd"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FlowEnd"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var flowEndReader = new FlowEndReader(cache, this, externalReferenceService, loggerFactory);
+                    var flowEndReader = new FlowEndReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return flowEndReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FlowUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FlowUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var flowUsageReader = new FlowUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var flowUsageReader = new FlowUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return flowUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ForkNode"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ForkNode"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var forkNodeReader = new ForkNodeReader(cache, this, externalReferenceService, loggerFactory);
+                    var forkNodeReader = new ForkNodeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return forkNodeReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ForLoopActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ForLoopActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var forLoopActionUsageReader = new ForLoopActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var forLoopActionUsageReader = new ForLoopActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return forLoopActionUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:FramedConcernMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FramedConcernMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var framedConcernMembershipReader = new FramedConcernMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var framedConcernMembershipReader = new FramedConcernMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return framedConcernMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Function"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Function"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var functionReader = new FunctionReader(cache, this, externalReferenceService, loggerFactory);
+                    var functionReader = new FunctionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return functionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:IfActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:IfActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var ifActionUsageReader = new IfActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var ifActionUsageReader = new IfActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return ifActionUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:IncludeUseCaseUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:IncludeUseCaseUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var includeUseCaseUsageReader = new IncludeUseCaseUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var includeUseCaseUsageReader = new IncludeUseCaseUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return includeUseCaseUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:IndexExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:IndexExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var indexExpressionReader = new IndexExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var indexExpressionReader = new IndexExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return indexExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Interaction"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Interaction"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var interactionReader = new InteractionReader(cache, this, externalReferenceService, loggerFactory);
+                    var interactionReader = new InteractionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return interactionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:InterfaceDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:InterfaceDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var interfaceDefinitionReader = new InterfaceDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var interfaceDefinitionReader = new InterfaceDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return interfaceDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:InterfaceUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:InterfaceUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var interfaceUsageReader = new InterfaceUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var interfaceUsageReader = new InterfaceUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return interfaceUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Intersecting"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Intersecting"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var intersectingReader = new IntersectingReader(cache, this, externalReferenceService, loggerFactory);
+                    var intersectingReader = new IntersectingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return intersectingReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Invariant"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Invariant"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var invariantReader = new InvariantReader(cache, this, externalReferenceService, loggerFactory);
+                    var invariantReader = new InvariantReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return invariantReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:InvocationExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:InvocationExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var invocationExpressionReader = new InvocationExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var invocationExpressionReader = new InvocationExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return invocationExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ItemDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ItemDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var itemDefinitionReader = new ItemDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var itemDefinitionReader = new ItemDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return itemDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ItemUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ItemUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var itemUsageReader = new ItemUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var itemUsageReader = new ItemUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return itemUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:JoinNode"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:JoinNode"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var joinNodeReader = new JoinNodeReader(cache, this, externalReferenceService, loggerFactory);
+                    var joinNodeReader = new JoinNodeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return joinNodeReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:LibraryPackage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LibraryPackage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var libraryPackageReader = new LibraryPackageReader(cache, this, externalReferenceService, loggerFactory);
+                    var libraryPackageReader = new LibraryPackageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return libraryPackageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralBoolean"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralBoolean"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalBooleanReader = new LiteralBooleanReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalBooleanReader = new LiteralBooleanReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return literalBooleanReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalExpressionReader = new LiteralExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalExpressionReader = new LiteralExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return literalExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralInfinity"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralInfinity"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalInfinityReader = new LiteralInfinityReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalInfinityReader = new LiteralInfinityReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return literalInfinityReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralInteger"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralInteger"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalIntegerReader = new LiteralIntegerReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalIntegerReader = new LiteralIntegerReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return literalIntegerReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralRational"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralRational"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalRationalReader = new LiteralRationalReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalRationalReader = new LiteralRationalReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return literalRationalReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralString"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralString"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalStringReader = new LiteralStringReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalStringReader = new LiteralStringReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return literalStringReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Membership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Membership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var membershipReader = new MembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var membershipReader = new MembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return membershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:MembershipExpose"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MembershipExpose"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var membershipExposeReader = new MembershipExposeReader(cache, this, externalReferenceService, loggerFactory);
+                    var membershipExposeReader = new MembershipExposeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return membershipExposeReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:MembershipImport"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MembershipImport"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var membershipImportReader = new MembershipImportReader(cache, this, externalReferenceService, loggerFactory);
+                    var membershipImportReader = new MembershipImportReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return membershipImportReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:MergeNode"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MergeNode"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var mergeNodeReader = new MergeNodeReader(cache, this, externalReferenceService, loggerFactory);
+                    var mergeNodeReader = new MergeNodeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return mergeNodeReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Metaclass"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Metaclass"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var metaclassReader = new MetaclassReader(cache, this, externalReferenceService, loggerFactory);
+                    var metaclassReader = new MetaclassReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return metaclassReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:MetadataAccessExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MetadataAccessExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var metadataAccessExpressionReader = new MetadataAccessExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var metadataAccessExpressionReader = new MetadataAccessExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return metadataAccessExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:MetadataDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MetadataDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var metadataDefinitionReader = new MetadataDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var metadataDefinitionReader = new MetadataDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return metadataDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:MetadataFeature"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MetadataFeature"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var metadataFeatureReader = new MetadataFeatureReader(cache, this, externalReferenceService, loggerFactory);
+                    var metadataFeatureReader = new MetadataFeatureReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return metadataFeatureReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:MetadataUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MetadataUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var metadataUsageReader = new MetadataUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var metadataUsageReader = new MetadataUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return metadataUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Multiplicity"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Multiplicity"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var multiplicityReader = new MultiplicityReader(cache, this, externalReferenceService, loggerFactory);
+                    var multiplicityReader = new MultiplicityReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return multiplicityReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:MultiplicityRange"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MultiplicityRange"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var multiplicityRangeReader = new MultiplicityRangeReader(cache, this, externalReferenceService, loggerFactory);
+                    var multiplicityRangeReader = new MultiplicityRangeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return multiplicityRangeReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Namespace"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Namespace"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var namespaceReader = new NamespaceReader(cache, this, externalReferenceService, loggerFactory);
+                    var namespaceReader = new NamespaceReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return namespaceReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:NamespaceExpose"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:NamespaceExpose"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var namespaceExposeReader = new NamespaceExposeReader(cache, this, externalReferenceService, loggerFactory);
+                    var namespaceExposeReader = new NamespaceExposeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return namespaceExposeReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:NamespaceImport"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:NamespaceImport"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var namespaceImportReader = new NamespaceImportReader(cache, this, externalReferenceService, loggerFactory);
+                    var namespaceImportReader = new NamespaceImportReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return namespaceImportReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:NullExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:NullExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var nullExpressionReader = new NullExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var nullExpressionReader = new NullExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return nullExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ObjectiveMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ObjectiveMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var objectiveMembershipReader = new ObjectiveMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var objectiveMembershipReader = new ObjectiveMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return objectiveMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:OccurrenceDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:OccurrenceDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var occurrenceDefinitionReader = new OccurrenceDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var occurrenceDefinitionReader = new OccurrenceDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return occurrenceDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:OccurrenceUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:OccurrenceUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var occurrenceUsageReader = new OccurrenceUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var occurrenceUsageReader = new OccurrenceUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return occurrenceUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:OperatorExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:OperatorExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var operatorExpressionReader = new OperatorExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var operatorExpressionReader = new OperatorExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return operatorExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:OwningMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:OwningMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var owningMembershipReader = new OwningMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var owningMembershipReader = new OwningMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return owningMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Package"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Package"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var packageReader = new PackageReader(cache, this, externalReferenceService, loggerFactory);
+                    var packageReader = new PackageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return packageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ParameterMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ParameterMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var parameterMembershipReader = new ParameterMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var parameterMembershipReader = new ParameterMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return parameterMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:PartDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PartDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var partDefinitionReader = new PartDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var partDefinitionReader = new PartDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return partDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:PartUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PartUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var partUsageReader = new PartUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var partUsageReader = new PartUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return partUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:PayloadFeature"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PayloadFeature"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var payloadFeatureReader = new PayloadFeatureReader(cache, this, externalReferenceService, loggerFactory);
+                    var payloadFeatureReader = new PayloadFeatureReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return payloadFeatureReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:PerformActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PerformActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var performActionUsageReader = new PerformActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var performActionUsageReader = new PerformActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return performActionUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:PortConjugation"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PortConjugation"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var portConjugationReader = new PortConjugationReader(cache, this, externalReferenceService, loggerFactory);
+                    var portConjugationReader = new PortConjugationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return portConjugationReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:PortDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PortDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var portDefinitionReader = new PortDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var portDefinitionReader = new PortDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return portDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:PortUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PortUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var portUsageReader = new PortUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var portUsageReader = new PortUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return portUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Predicate"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Predicate"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var predicateReader = new PredicateReader(cache, this, externalReferenceService, loggerFactory);
+                    var predicateReader = new PredicateReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return predicateReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Redefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Redefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var redefinitionReader = new RedefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var redefinitionReader = new RedefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return redefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ReferenceSubsetting"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ReferenceSubsetting"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var referenceSubsettingReader = new ReferenceSubsettingReader(cache, this, externalReferenceService, loggerFactory);
+                    var referenceSubsettingReader = new ReferenceSubsettingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return referenceSubsettingReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ReferenceUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ReferenceUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var referenceUsageReader = new ReferenceUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var referenceUsageReader = new ReferenceUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return referenceUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:RenderingDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RenderingDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var renderingDefinitionReader = new RenderingDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var renderingDefinitionReader = new RenderingDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return renderingDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:RenderingUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RenderingUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var renderingUsageReader = new RenderingUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var renderingUsageReader = new RenderingUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return renderingUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:RequirementConstraintMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RequirementConstraintMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var requirementConstraintMembershipReader = new RequirementConstraintMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var requirementConstraintMembershipReader = new RequirementConstraintMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return requirementConstraintMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:RequirementDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RequirementDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var requirementDefinitionReader = new RequirementDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var requirementDefinitionReader = new RequirementDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return requirementDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:RequirementUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RequirementUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var requirementUsageReader = new RequirementUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var requirementUsageReader = new RequirementUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return requirementUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:RequirementVerificationMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RequirementVerificationMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var requirementVerificationMembershipReader = new RequirementVerificationMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var requirementVerificationMembershipReader = new RequirementVerificationMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return requirementVerificationMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ResultExpressionMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ResultExpressionMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var resultExpressionMembershipReader = new ResultExpressionMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var resultExpressionMembershipReader = new ResultExpressionMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return resultExpressionMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ReturnParameterMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ReturnParameterMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var returnParameterMembershipReader = new ReturnParameterMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var returnParameterMembershipReader = new ReturnParameterMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return returnParameterMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:SatisfyRequirementUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SatisfyRequirementUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var satisfyRequirementUsageReader = new SatisfyRequirementUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var satisfyRequirementUsageReader = new SatisfyRequirementUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return satisfyRequirementUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:SelectExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SelectExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var selectExpressionReader = new SelectExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var selectExpressionReader = new SelectExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return selectExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:SendActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SendActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var sendActionUsageReader = new SendActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var sendActionUsageReader = new SendActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return sendActionUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Specialization"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Specialization"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var specializationReader = new SpecializationReader(cache, this, externalReferenceService, loggerFactory);
+                    var specializationReader = new SpecializationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return specializationReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:StakeholderMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:StakeholderMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var stakeholderMembershipReader = new StakeholderMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var stakeholderMembershipReader = new StakeholderMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return stakeholderMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:StateDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:StateDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var stateDefinitionReader = new StateDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var stateDefinitionReader = new StateDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return stateDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:StateSubactionMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:StateSubactionMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var stateSubactionMembershipReader = new StateSubactionMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var stateSubactionMembershipReader = new StateSubactionMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return stateSubactionMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:StateUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:StateUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var stateUsageReader = new StateUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var stateUsageReader = new StateUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return stateUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Step"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Step"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var stepReader = new StepReader(cache, this, externalReferenceService, loggerFactory);
+                    var stepReader = new StepReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return stepReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Structure"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Structure"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var structureReader = new StructureReader(cache, this, externalReferenceService, loggerFactory);
+                    var structureReader = new StructureReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return structureReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Subclassification"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Subclassification"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var subclassificationReader = new SubclassificationReader(cache, this, externalReferenceService, loggerFactory);
+                    var subclassificationReader = new SubclassificationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return subclassificationReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:SubjectMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SubjectMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var subjectMembershipReader = new SubjectMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var subjectMembershipReader = new SubjectMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return subjectMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Subsetting"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Subsetting"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var subsettingReader = new SubsettingReader(cache, this, externalReferenceService, loggerFactory);
+                    var subsettingReader = new SubsettingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return subsettingReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Succession"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Succession"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var successionReader = new SuccessionReader(cache, this, externalReferenceService, loggerFactory);
+                    var successionReader = new SuccessionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return successionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:SuccessionAsUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SuccessionAsUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var successionAsUsageReader = new SuccessionAsUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var successionAsUsageReader = new SuccessionAsUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return successionAsUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:SuccessionFlow"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SuccessionFlow"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var successionFlowReader = new SuccessionFlowReader(cache, this, externalReferenceService, loggerFactory);
+                    var successionFlowReader = new SuccessionFlowReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return successionFlowReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:SuccessionFlowUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SuccessionFlowUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var successionFlowUsageReader = new SuccessionFlowUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var successionFlowUsageReader = new SuccessionFlowUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return successionFlowUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:TerminateActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TerminateActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var terminateActionUsageReader = new TerminateActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var terminateActionUsageReader = new TerminateActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return terminateActionUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:TextualRepresentation"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TextualRepresentation"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var textualRepresentationReader = new TextualRepresentationReader(cache, this, externalReferenceService, loggerFactory);
+                    var textualRepresentationReader = new TextualRepresentationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return textualRepresentationReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:TransitionFeatureMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TransitionFeatureMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var transitionFeatureMembershipReader = new TransitionFeatureMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var transitionFeatureMembershipReader = new TransitionFeatureMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return transitionFeatureMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:TransitionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TransitionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var transitionUsageReader = new TransitionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var transitionUsageReader = new TransitionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return transitionUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:TriggerInvocationExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TriggerInvocationExpression"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var triggerInvocationExpressionReader = new TriggerInvocationExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var triggerInvocationExpressionReader = new TriggerInvocationExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return triggerInvocationExpressionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Type"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Type"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var typeReader = new TypeReader(cache, this, externalReferenceService, loggerFactory);
+                    var typeReader = new TypeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return typeReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:TypeFeaturing"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TypeFeaturing"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var typeFeaturingReader = new TypeFeaturingReader(cache, this, externalReferenceService, loggerFactory);
+                    var typeFeaturingReader = new TypeFeaturingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return typeFeaturingReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Unioning"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Unioning"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var unioningReader = new UnioningReader(cache, this, externalReferenceService, loggerFactory);
+                    var unioningReader = new UnioningReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return unioningReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:Usage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Usage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var usageReader = new UsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var usageReader = new UsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return usageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:UseCaseDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:UseCaseDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var useCaseDefinitionReader = new UseCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var useCaseDefinitionReader = new UseCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return useCaseDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:UseCaseUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:UseCaseUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var useCaseUsageReader = new UseCaseUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var useCaseUsageReader = new UseCaseUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return useCaseUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:VariantMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:VariantMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var variantMembershipReader = new VariantMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var variantMembershipReader = new VariantMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return variantMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:VerificationCaseDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:VerificationCaseDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var verificationCaseDefinitionReader = new VerificationCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var verificationCaseDefinitionReader = new VerificationCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return verificationCaseDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:VerificationCaseUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:VerificationCaseUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var verificationCaseUsageReader = new VerificationCaseUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var verificationCaseUsageReader = new VerificationCaseUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return verificationCaseUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ViewDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ViewDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var viewDefinitionReader = new ViewDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var viewDefinitionReader = new ViewDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return viewDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ViewpointDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ViewpointDefinition"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var viewpointDefinitionReader = new ViewpointDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var viewpointDefinitionReader = new ViewpointDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return viewpointDefinitionReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ViewpointUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ViewpointUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var viewpointUsageReader = new ViewpointUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var viewpointUsageReader = new ViewpointUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return viewpointUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ViewRenderingMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ViewRenderingMembership"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var viewRenderingMembershipReader = new ViewRenderingMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var viewRenderingMembershipReader = new ViewRenderingMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return viewRenderingMembershipReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:ViewUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ViewUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var viewUsageReader = new ViewUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var viewUsageReader = new ViewUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return viewUsageReader.Read(subXmlReader, currentLocation);
                 },
-                ["sysml:WhileLoopActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:WhileLoopActionUsage"] = (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var whileLoopActionUsageReader = new WhileLoopActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var whileLoopActionUsageReader = new WhileLoopActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return whileLoopActionUsageReader.Read(subXmlReader, currentLocation);
                 },
             };
 
-            this.readerAsyncCache = new Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, Task<IData>>>
+            this.readerAsyncCache = new Dictionary<string, Func<IXmiDataCache, IExternalReferenceService, ILoggerFactory, XmlReader, Uri, IXmiElementOriginMap, Task<IData>>>
             {
-                ["sysml:AcceptActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AcceptActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var acceptActionUsageReader = new AcceptActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var acceptActionUsageReader = new AcceptActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await acceptActionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ActionDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ActionDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var actionDefinitionReader = new ActionDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var actionDefinitionReader = new ActionDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await actionDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var actionUsageReader = new ActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var actionUsageReader = new ActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await actionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ActorMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ActorMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var actorMembershipReader = new ActorMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var actorMembershipReader = new ActorMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await actorMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:AllocationDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AllocationDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var allocationDefinitionReader = new AllocationDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var allocationDefinitionReader = new AllocationDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await allocationDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:AllocationUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AllocationUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var allocationUsageReader = new AllocationUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var allocationUsageReader = new AllocationUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await allocationUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:AnalysisCaseDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AnalysisCaseDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var analysisCaseDefinitionReader = new AnalysisCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var analysisCaseDefinitionReader = new AnalysisCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await analysisCaseDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:AnalysisCaseUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AnalysisCaseUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var analysisCaseUsageReader = new AnalysisCaseUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var analysisCaseUsageReader = new AnalysisCaseUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await analysisCaseUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:AnnotatingElement"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AnnotatingElement"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var annotatingElementReader = new AnnotatingElementReader(cache, this, externalReferenceService, loggerFactory);
+                    var annotatingElementReader = new AnnotatingElementReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await annotatingElementReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Annotation"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Annotation"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var annotationReader = new AnnotationReader(cache, this, externalReferenceService, loggerFactory);
+                    var annotationReader = new AnnotationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await annotationReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:AssertConstraintUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AssertConstraintUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var assertConstraintUsageReader = new AssertConstraintUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var assertConstraintUsageReader = new AssertConstraintUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await assertConstraintUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:AssignmentActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AssignmentActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var assignmentActionUsageReader = new AssignmentActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var assignmentActionUsageReader = new AssignmentActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await assignmentActionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Association"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Association"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var associationReader = new AssociationReader(cache, this, externalReferenceService, loggerFactory);
+                    var associationReader = new AssociationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await associationReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:AssociationStructure"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AssociationStructure"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var associationStructureReader = new AssociationStructureReader(cache, this, externalReferenceService, loggerFactory);
+                    var associationStructureReader = new AssociationStructureReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await associationStructureReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:AttributeDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AttributeDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var attributeDefinitionReader = new AttributeDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var attributeDefinitionReader = new AttributeDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await attributeDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:AttributeUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:AttributeUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var attributeUsageReader = new AttributeUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var attributeUsageReader = new AttributeUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await attributeUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Behavior"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Behavior"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var behaviorReader = new BehaviorReader(cache, this, externalReferenceService, loggerFactory);
+                    var behaviorReader = new BehaviorReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await behaviorReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:BindingConnector"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:BindingConnector"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var bindingConnectorReader = new BindingConnectorReader(cache, this, externalReferenceService, loggerFactory);
+                    var bindingConnectorReader = new BindingConnectorReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await bindingConnectorReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:BindingConnectorAsUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:BindingConnectorAsUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var bindingConnectorAsUsageReader = new BindingConnectorAsUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var bindingConnectorAsUsageReader = new BindingConnectorAsUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await bindingConnectorAsUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:BooleanExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:BooleanExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var booleanExpressionReader = new BooleanExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var booleanExpressionReader = new BooleanExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await booleanExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:CalculationDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CalculationDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var calculationDefinitionReader = new CalculationDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var calculationDefinitionReader = new CalculationDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await calculationDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:CalculationUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CalculationUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var calculationUsageReader = new CalculationUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var calculationUsageReader = new CalculationUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await calculationUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:CaseDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CaseDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var caseDefinitionReader = new CaseDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var caseDefinitionReader = new CaseDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await caseDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:CaseUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CaseUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var caseUsageReader = new CaseUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var caseUsageReader = new CaseUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await caseUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Class"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Class"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var classReader = new ClassReader(cache, this, externalReferenceService, loggerFactory);
+                    var classReader = new ClassReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await classReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Classifier"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Classifier"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var classifierReader = new ClassifierReader(cache, this, externalReferenceService, loggerFactory);
+                    var classifierReader = new ClassifierReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await classifierReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:CollectExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CollectExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var collectExpressionReader = new CollectExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var collectExpressionReader = new CollectExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await collectExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Comment"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Comment"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var commentReader = new CommentReader(cache, this, externalReferenceService, loggerFactory);
+                    var commentReader = new CommentReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await commentReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ConcernDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConcernDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var concernDefinitionReader = new ConcernDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var concernDefinitionReader = new ConcernDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await concernDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ConcernUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConcernUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var concernUsageReader = new ConcernUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var concernUsageReader = new ConcernUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await concernUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ConjugatedPortDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConjugatedPortDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var conjugatedPortDefinitionReader = new ConjugatedPortDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var conjugatedPortDefinitionReader = new ConjugatedPortDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await conjugatedPortDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ConjugatedPortTyping"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConjugatedPortTyping"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var conjugatedPortTypingReader = new ConjugatedPortTypingReader(cache, this, externalReferenceService, loggerFactory);
+                    var conjugatedPortTypingReader = new ConjugatedPortTypingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await conjugatedPortTypingReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Conjugation"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Conjugation"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var conjugationReader = new ConjugationReader(cache, this, externalReferenceService, loggerFactory);
+                    var conjugationReader = new ConjugationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await conjugationReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ConnectionDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConnectionDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var connectionDefinitionReader = new ConnectionDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var connectionDefinitionReader = new ConnectionDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await connectionDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ConnectionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConnectionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var connectionUsageReader = new ConnectionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var connectionUsageReader = new ConnectionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await connectionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Connector"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Connector"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var connectorReader = new ConnectorReader(cache, this, externalReferenceService, loggerFactory);
+                    var connectorReader = new ConnectorReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await connectorReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ConstraintDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConstraintDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var constraintDefinitionReader = new ConstraintDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var constraintDefinitionReader = new ConstraintDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await constraintDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ConstraintUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConstraintUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var constraintUsageReader = new ConstraintUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var constraintUsageReader = new ConstraintUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await constraintUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ConstructorExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ConstructorExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var constructorExpressionReader = new ConstructorExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var constructorExpressionReader = new ConstructorExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await constructorExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:CrossSubsetting"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:CrossSubsetting"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var crossSubsettingReader = new CrossSubsettingReader(cache, this, externalReferenceService, loggerFactory);
+                    var crossSubsettingReader = new CrossSubsettingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await crossSubsettingReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:DataType"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:DataType"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var dataTypeReader = new DataTypeReader(cache, this, externalReferenceService, loggerFactory);
+                    var dataTypeReader = new DataTypeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await dataTypeReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:DecisionNode"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:DecisionNode"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var decisionNodeReader = new DecisionNodeReader(cache, this, externalReferenceService, loggerFactory);
+                    var decisionNodeReader = new DecisionNodeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await decisionNodeReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Definition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Definition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var definitionReader = new DefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var definitionReader = new DefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await definitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Dependency"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Dependency"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var dependencyReader = new DependencyReader(cache, this, externalReferenceService, loggerFactory);
+                    var dependencyReader = new DependencyReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await dependencyReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Differencing"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Differencing"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var differencingReader = new DifferencingReader(cache, this, externalReferenceService, loggerFactory);
+                    var differencingReader = new DifferencingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await differencingReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Disjoining"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Disjoining"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var disjoiningReader = new DisjoiningReader(cache, this, externalReferenceService, loggerFactory);
+                    var disjoiningReader = new DisjoiningReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await disjoiningReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Documentation"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Documentation"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var documentationReader = new DocumentationReader(cache, this, externalReferenceService, loggerFactory);
+                    var documentationReader = new DocumentationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await documentationReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ElementFilterMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ElementFilterMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var elementFilterMembershipReader = new ElementFilterMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var elementFilterMembershipReader = new ElementFilterMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await elementFilterMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:EndFeatureMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:EndFeatureMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var endFeatureMembershipReader = new EndFeatureMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var endFeatureMembershipReader = new EndFeatureMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await endFeatureMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:EnumerationDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:EnumerationDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var enumerationDefinitionReader = new EnumerationDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var enumerationDefinitionReader = new EnumerationDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await enumerationDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:EnumerationUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:EnumerationUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var enumerationUsageReader = new EnumerationUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var enumerationUsageReader = new EnumerationUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await enumerationUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:EventOccurrenceUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:EventOccurrenceUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var eventOccurrenceUsageReader = new EventOccurrenceUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var eventOccurrenceUsageReader = new EventOccurrenceUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await eventOccurrenceUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ExhibitStateUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ExhibitStateUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var exhibitStateUsageReader = new ExhibitStateUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var exhibitStateUsageReader = new ExhibitStateUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await exhibitStateUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Expression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Expression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var expressionReader = new ExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var expressionReader = new ExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await expressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Feature"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Feature"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureReader = new FeatureReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureReader = new FeatureReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await featureReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureChainExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureChainExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureChainExpressionReader = new FeatureChainExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureChainExpressionReader = new FeatureChainExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await featureChainExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureChaining"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureChaining"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureChainingReader = new FeatureChainingReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureChainingReader = new FeatureChainingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await featureChainingReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureInverting"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureInverting"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureInvertingReader = new FeatureInvertingReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureInvertingReader = new FeatureInvertingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await featureInvertingReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureMembershipReader = new FeatureMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureMembershipReader = new FeatureMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await featureMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureReferenceExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureReferenceExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureReferenceExpressionReader = new FeatureReferenceExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureReferenceExpressionReader = new FeatureReferenceExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await featureReferenceExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureTyping"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureTyping"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureTypingReader = new FeatureTypingReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureTypingReader = new FeatureTypingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await featureTypingReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FeatureValue"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FeatureValue"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var featureValueReader = new FeatureValueReader(cache, this, externalReferenceService, loggerFactory);
+                    var featureValueReader = new FeatureValueReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await featureValueReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Flow"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Flow"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var flowReader = new FlowReader(cache, this, externalReferenceService, loggerFactory);
+                    var flowReader = new FlowReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await flowReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FlowDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FlowDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var flowDefinitionReader = new FlowDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var flowDefinitionReader = new FlowDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await flowDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FlowEnd"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FlowEnd"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var flowEndReader = new FlowEndReader(cache, this, externalReferenceService, loggerFactory);
+                    var flowEndReader = new FlowEndReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await flowEndReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FlowUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FlowUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var flowUsageReader = new FlowUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var flowUsageReader = new FlowUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await flowUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ForkNode"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ForkNode"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var forkNodeReader = new ForkNodeReader(cache, this, externalReferenceService, loggerFactory);
+                    var forkNodeReader = new ForkNodeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await forkNodeReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ForLoopActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ForLoopActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var forLoopActionUsageReader = new ForLoopActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var forLoopActionUsageReader = new ForLoopActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await forLoopActionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:FramedConcernMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:FramedConcernMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var framedConcernMembershipReader = new FramedConcernMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var framedConcernMembershipReader = new FramedConcernMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await framedConcernMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Function"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Function"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var functionReader = new FunctionReader(cache, this, externalReferenceService, loggerFactory);
+                    var functionReader = new FunctionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await functionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:IfActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:IfActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var ifActionUsageReader = new IfActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var ifActionUsageReader = new IfActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await ifActionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:IncludeUseCaseUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:IncludeUseCaseUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var includeUseCaseUsageReader = new IncludeUseCaseUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var includeUseCaseUsageReader = new IncludeUseCaseUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await includeUseCaseUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:IndexExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:IndexExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var indexExpressionReader = new IndexExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var indexExpressionReader = new IndexExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await indexExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Interaction"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Interaction"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var interactionReader = new InteractionReader(cache, this, externalReferenceService, loggerFactory);
+                    var interactionReader = new InteractionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await interactionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:InterfaceDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:InterfaceDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var interfaceDefinitionReader = new InterfaceDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var interfaceDefinitionReader = new InterfaceDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await interfaceDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:InterfaceUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:InterfaceUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var interfaceUsageReader = new InterfaceUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var interfaceUsageReader = new InterfaceUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await interfaceUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Intersecting"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Intersecting"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var intersectingReader = new IntersectingReader(cache, this, externalReferenceService, loggerFactory);
+                    var intersectingReader = new IntersectingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await intersectingReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Invariant"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Invariant"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var invariantReader = new InvariantReader(cache, this, externalReferenceService, loggerFactory);
+                    var invariantReader = new InvariantReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await invariantReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:InvocationExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:InvocationExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var invocationExpressionReader = new InvocationExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var invocationExpressionReader = new InvocationExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await invocationExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ItemDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ItemDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var itemDefinitionReader = new ItemDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var itemDefinitionReader = new ItemDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await itemDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ItemUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ItemUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var itemUsageReader = new ItemUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var itemUsageReader = new ItemUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await itemUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:JoinNode"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:JoinNode"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var joinNodeReader = new JoinNodeReader(cache, this, externalReferenceService, loggerFactory);
+                    var joinNodeReader = new JoinNodeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await joinNodeReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:LibraryPackage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LibraryPackage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var libraryPackageReader = new LibraryPackageReader(cache, this, externalReferenceService, loggerFactory);
+                    var libraryPackageReader = new LibraryPackageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await libraryPackageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralBoolean"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralBoolean"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalBooleanReader = new LiteralBooleanReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalBooleanReader = new LiteralBooleanReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await literalBooleanReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalExpressionReader = new LiteralExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalExpressionReader = new LiteralExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await literalExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralInfinity"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralInfinity"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalInfinityReader = new LiteralInfinityReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalInfinityReader = new LiteralInfinityReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await literalInfinityReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralInteger"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralInteger"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalIntegerReader = new LiteralIntegerReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalIntegerReader = new LiteralIntegerReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await literalIntegerReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralRational"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralRational"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalRationalReader = new LiteralRationalReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalRationalReader = new LiteralRationalReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await literalRationalReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:LiteralString"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:LiteralString"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var literalStringReader = new LiteralStringReader(cache, this, externalReferenceService, loggerFactory);
+                    var literalStringReader = new LiteralStringReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await literalStringReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Membership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Membership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var membershipReader = new MembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var membershipReader = new MembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await membershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:MembershipExpose"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MembershipExpose"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var membershipExposeReader = new MembershipExposeReader(cache, this, externalReferenceService, loggerFactory);
+                    var membershipExposeReader = new MembershipExposeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await membershipExposeReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:MembershipImport"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MembershipImport"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var membershipImportReader = new MembershipImportReader(cache, this, externalReferenceService, loggerFactory);
+                    var membershipImportReader = new MembershipImportReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await membershipImportReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:MergeNode"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MergeNode"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var mergeNodeReader = new MergeNodeReader(cache, this, externalReferenceService, loggerFactory);
+                    var mergeNodeReader = new MergeNodeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await mergeNodeReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Metaclass"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Metaclass"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var metaclassReader = new MetaclassReader(cache, this, externalReferenceService, loggerFactory);
+                    var metaclassReader = new MetaclassReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await metaclassReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:MetadataAccessExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MetadataAccessExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var metadataAccessExpressionReader = new MetadataAccessExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var metadataAccessExpressionReader = new MetadataAccessExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await metadataAccessExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:MetadataDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MetadataDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var metadataDefinitionReader = new MetadataDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var metadataDefinitionReader = new MetadataDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await metadataDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:MetadataFeature"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MetadataFeature"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var metadataFeatureReader = new MetadataFeatureReader(cache, this, externalReferenceService, loggerFactory);
+                    var metadataFeatureReader = new MetadataFeatureReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await metadataFeatureReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:MetadataUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MetadataUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var metadataUsageReader = new MetadataUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var metadataUsageReader = new MetadataUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await metadataUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Multiplicity"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Multiplicity"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var multiplicityReader = new MultiplicityReader(cache, this, externalReferenceService, loggerFactory);
+                    var multiplicityReader = new MultiplicityReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await multiplicityReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:MultiplicityRange"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:MultiplicityRange"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var multiplicityRangeReader = new MultiplicityRangeReader(cache, this, externalReferenceService, loggerFactory);
+                    var multiplicityRangeReader = new MultiplicityRangeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await multiplicityRangeReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Namespace"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Namespace"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var namespaceReader = new NamespaceReader(cache, this, externalReferenceService, loggerFactory);
+                    var namespaceReader = new NamespaceReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await namespaceReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:NamespaceExpose"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:NamespaceExpose"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var namespaceExposeReader = new NamespaceExposeReader(cache, this, externalReferenceService, loggerFactory);
+                    var namespaceExposeReader = new NamespaceExposeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await namespaceExposeReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:NamespaceImport"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:NamespaceImport"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var namespaceImportReader = new NamespaceImportReader(cache, this, externalReferenceService, loggerFactory);
+                    var namespaceImportReader = new NamespaceImportReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await namespaceImportReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:NullExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:NullExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var nullExpressionReader = new NullExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var nullExpressionReader = new NullExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await nullExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ObjectiveMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ObjectiveMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var objectiveMembershipReader = new ObjectiveMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var objectiveMembershipReader = new ObjectiveMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await objectiveMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:OccurrenceDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:OccurrenceDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var occurrenceDefinitionReader = new OccurrenceDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var occurrenceDefinitionReader = new OccurrenceDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await occurrenceDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:OccurrenceUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:OccurrenceUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var occurrenceUsageReader = new OccurrenceUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var occurrenceUsageReader = new OccurrenceUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await occurrenceUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:OperatorExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:OperatorExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var operatorExpressionReader = new OperatorExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var operatorExpressionReader = new OperatorExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await operatorExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:OwningMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:OwningMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var owningMembershipReader = new OwningMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var owningMembershipReader = new OwningMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await owningMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Package"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Package"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var packageReader = new PackageReader(cache, this, externalReferenceService, loggerFactory);
+                    var packageReader = new PackageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await packageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ParameterMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ParameterMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var parameterMembershipReader = new ParameterMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var parameterMembershipReader = new ParameterMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await parameterMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:PartDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PartDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var partDefinitionReader = new PartDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var partDefinitionReader = new PartDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await partDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:PartUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PartUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var partUsageReader = new PartUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var partUsageReader = new PartUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await partUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:PayloadFeature"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PayloadFeature"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var payloadFeatureReader = new PayloadFeatureReader(cache, this, externalReferenceService, loggerFactory);
+                    var payloadFeatureReader = new PayloadFeatureReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await payloadFeatureReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:PerformActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PerformActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var performActionUsageReader = new PerformActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var performActionUsageReader = new PerformActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await performActionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:PortConjugation"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PortConjugation"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var portConjugationReader = new PortConjugationReader(cache, this, externalReferenceService, loggerFactory);
+                    var portConjugationReader = new PortConjugationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await portConjugationReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:PortDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PortDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var portDefinitionReader = new PortDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var portDefinitionReader = new PortDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await portDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:PortUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:PortUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var portUsageReader = new PortUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var portUsageReader = new PortUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await portUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Predicate"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Predicate"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var predicateReader = new PredicateReader(cache, this, externalReferenceService, loggerFactory);
+                    var predicateReader = new PredicateReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await predicateReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Redefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Redefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var redefinitionReader = new RedefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var redefinitionReader = new RedefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await redefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ReferenceSubsetting"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ReferenceSubsetting"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var referenceSubsettingReader = new ReferenceSubsettingReader(cache, this, externalReferenceService, loggerFactory);
+                    var referenceSubsettingReader = new ReferenceSubsettingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await referenceSubsettingReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ReferenceUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ReferenceUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var referenceUsageReader = new ReferenceUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var referenceUsageReader = new ReferenceUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await referenceUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:RenderingDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RenderingDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var renderingDefinitionReader = new RenderingDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var renderingDefinitionReader = new RenderingDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await renderingDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:RenderingUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RenderingUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var renderingUsageReader = new RenderingUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var renderingUsageReader = new RenderingUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await renderingUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:RequirementConstraintMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RequirementConstraintMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var requirementConstraintMembershipReader = new RequirementConstraintMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var requirementConstraintMembershipReader = new RequirementConstraintMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await requirementConstraintMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:RequirementDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RequirementDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var requirementDefinitionReader = new RequirementDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var requirementDefinitionReader = new RequirementDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await requirementDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:RequirementUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RequirementUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var requirementUsageReader = new RequirementUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var requirementUsageReader = new RequirementUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await requirementUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:RequirementVerificationMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:RequirementVerificationMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var requirementVerificationMembershipReader = new RequirementVerificationMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var requirementVerificationMembershipReader = new RequirementVerificationMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await requirementVerificationMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ResultExpressionMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ResultExpressionMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var resultExpressionMembershipReader = new ResultExpressionMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var resultExpressionMembershipReader = new ResultExpressionMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await resultExpressionMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ReturnParameterMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ReturnParameterMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var returnParameterMembershipReader = new ReturnParameterMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var returnParameterMembershipReader = new ReturnParameterMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await returnParameterMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:SatisfyRequirementUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SatisfyRequirementUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var satisfyRequirementUsageReader = new SatisfyRequirementUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var satisfyRequirementUsageReader = new SatisfyRequirementUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await satisfyRequirementUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:SelectExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SelectExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var selectExpressionReader = new SelectExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var selectExpressionReader = new SelectExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await selectExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:SendActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SendActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var sendActionUsageReader = new SendActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var sendActionUsageReader = new SendActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await sendActionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Specialization"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Specialization"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var specializationReader = new SpecializationReader(cache, this, externalReferenceService, loggerFactory);
+                    var specializationReader = new SpecializationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await specializationReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:StakeholderMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:StakeholderMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var stakeholderMembershipReader = new StakeholderMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var stakeholderMembershipReader = new StakeholderMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await stakeholderMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:StateDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:StateDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var stateDefinitionReader = new StateDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var stateDefinitionReader = new StateDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await stateDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:StateSubactionMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:StateSubactionMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var stateSubactionMembershipReader = new StateSubactionMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var stateSubactionMembershipReader = new StateSubactionMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await stateSubactionMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:StateUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:StateUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var stateUsageReader = new StateUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var stateUsageReader = new StateUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await stateUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Step"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Step"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var stepReader = new StepReader(cache, this, externalReferenceService, loggerFactory);
+                    var stepReader = new StepReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await stepReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Structure"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Structure"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var structureReader = new StructureReader(cache, this, externalReferenceService, loggerFactory);
+                    var structureReader = new StructureReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await structureReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Subclassification"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Subclassification"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var subclassificationReader = new SubclassificationReader(cache, this, externalReferenceService, loggerFactory);
+                    var subclassificationReader = new SubclassificationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await subclassificationReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:SubjectMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SubjectMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var subjectMembershipReader = new SubjectMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var subjectMembershipReader = new SubjectMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await subjectMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Subsetting"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Subsetting"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var subsettingReader = new SubsettingReader(cache, this, externalReferenceService, loggerFactory);
+                    var subsettingReader = new SubsettingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await subsettingReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Succession"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Succession"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var successionReader = new SuccessionReader(cache, this, externalReferenceService, loggerFactory);
+                    var successionReader = new SuccessionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await successionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:SuccessionAsUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SuccessionAsUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var successionAsUsageReader = new SuccessionAsUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var successionAsUsageReader = new SuccessionAsUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await successionAsUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:SuccessionFlow"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SuccessionFlow"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var successionFlowReader = new SuccessionFlowReader(cache, this, externalReferenceService, loggerFactory);
+                    var successionFlowReader = new SuccessionFlowReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await successionFlowReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:SuccessionFlowUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:SuccessionFlowUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var successionFlowUsageReader = new SuccessionFlowUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var successionFlowUsageReader = new SuccessionFlowUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await successionFlowUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:TerminateActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TerminateActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var terminateActionUsageReader = new TerminateActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var terminateActionUsageReader = new TerminateActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await terminateActionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:TextualRepresentation"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TextualRepresentation"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var textualRepresentationReader = new TextualRepresentationReader(cache, this, externalReferenceService, loggerFactory);
+                    var textualRepresentationReader = new TextualRepresentationReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await textualRepresentationReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:TransitionFeatureMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TransitionFeatureMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var transitionFeatureMembershipReader = new TransitionFeatureMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var transitionFeatureMembershipReader = new TransitionFeatureMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await transitionFeatureMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:TransitionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TransitionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var transitionUsageReader = new TransitionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var transitionUsageReader = new TransitionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await transitionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:TriggerInvocationExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TriggerInvocationExpression"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var triggerInvocationExpressionReader = new TriggerInvocationExpressionReader(cache, this, externalReferenceService, loggerFactory);
+                    var triggerInvocationExpressionReader = new TriggerInvocationExpressionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await triggerInvocationExpressionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Type"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Type"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var typeReader = new TypeReader(cache, this, externalReferenceService, loggerFactory);
+                    var typeReader = new TypeReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await typeReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:TypeFeaturing"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:TypeFeaturing"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var typeFeaturingReader = new TypeFeaturingReader(cache, this, externalReferenceService, loggerFactory);
+                    var typeFeaturingReader = new TypeFeaturingReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await typeFeaturingReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Unioning"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Unioning"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var unioningReader = new UnioningReader(cache, this, externalReferenceService, loggerFactory);
+                    var unioningReader = new UnioningReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await unioningReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:Usage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:Usage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var usageReader = new UsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var usageReader = new UsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await usageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:UseCaseDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:UseCaseDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var useCaseDefinitionReader = new UseCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var useCaseDefinitionReader = new UseCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await useCaseDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:UseCaseUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:UseCaseUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var useCaseUsageReader = new UseCaseUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var useCaseUsageReader = new UseCaseUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await useCaseUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:VariantMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:VariantMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var variantMembershipReader = new VariantMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var variantMembershipReader = new VariantMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await variantMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:VerificationCaseDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:VerificationCaseDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var verificationCaseDefinitionReader = new VerificationCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var verificationCaseDefinitionReader = new VerificationCaseDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await verificationCaseDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:VerificationCaseUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:VerificationCaseUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var verificationCaseUsageReader = new VerificationCaseUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var verificationCaseUsageReader = new VerificationCaseUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await verificationCaseUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ViewDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ViewDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var viewDefinitionReader = new ViewDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var viewDefinitionReader = new ViewDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await viewDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ViewpointDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ViewpointDefinition"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var viewpointDefinitionReader = new ViewpointDefinitionReader(cache, this, externalReferenceService, loggerFactory);
+                    var viewpointDefinitionReader = new ViewpointDefinitionReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await viewpointDefinitionReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ViewpointUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ViewpointUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var viewpointUsageReader = new ViewpointUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var viewpointUsageReader = new ViewpointUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await viewpointUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ViewRenderingMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ViewRenderingMembership"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var viewRenderingMembershipReader = new ViewRenderingMembershipReader(cache, this, externalReferenceService, loggerFactory);
+                    var viewRenderingMembershipReader = new ViewRenderingMembershipReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await viewRenderingMembershipReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:ViewUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:ViewUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var viewUsageReader = new ViewUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var viewUsageReader = new ViewUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await viewUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
-                ["sysml:WhileLoopActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation) =>
+                ["sysml:WhileLoopActionUsage"] = async (cache, externalReferenceService, loggerFactory, xmlReader, currentLocation, elementOriginMap) =>
                 {
                     using var subXmlReader = xmlReader.ReadSubtree();
-                    var whileLoopActionUsageReader = new WhileLoopActionUsageReader(cache, this, externalReferenceService, loggerFactory);
+                    var whileLoopActionUsageReader = new WhileLoopActionUsageReader(cache, this, externalReferenceService, loggerFactory, elementOriginMap);
                     return await whileLoopActionUsageReader.ReadAsync(subXmlReader, currentLocation);
                 },
             };
@@ -2083,7 +2083,7 @@ public XmiDataReaderFacade()
         /// <param name="explicitTypeName">The explicit type name to resolve, in case of un-specified xsi:type</param>
         /// <returns>An instance of the read <see cref="IData"/></returns>
         /// <exception cref="InvalidOperationException">If the xsi:type is not supported</exception>
-        public IData QueryXmiData(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "")
+        public IData QueryXmiData(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "", IXmiElementOriginMap elementOriginMap = null)
         {
             AssertValidQueryXmiDataParameters(xmiReader, xmiDataCache, currentLocation);
 
@@ -2098,7 +2098,7 @@ public IData QueryXmiData(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri c
 
             if (this.readerCache.TryGetValue(xsiType, out var readerFactory))
             {
-                return readerFactory(xmiDataCache, externalReferenceService, loggerFactory, xmiReader, currentLocation);
+                return readerFactory(xmiDataCache, externalReferenceService, loggerFactory, xmiReader, currentLocation, elementOriginMap);
             }
 
             throw new InvalidOperationException($"No reader found for xsi:type - {xsiType}");
@@ -2117,7 +2117,7 @@ public IData QueryXmiData(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri c
         /// <param name="explicitTypeName">The explicit type name to resolve, in case of un-specified xsi:type</param>
         /// <returns>An awaitable <see cref="Task" /> with the instance of the read <see cref="IData"/></returns>
         /// <exception cref="InvalidOperationException">If the xsi:type is not supported</exception>
-        public Task<IData> QueryXmiDataAsync(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "")
+        public Task<IData> QueryXmiDataAsync(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "", IXmiElementOriginMap elementOriginMap = null)
         {
             AssertValidQueryXmiDataParameters(xmiReader, xmiDataCache, currentLocation);
 
@@ -2132,7 +2132,7 @@ public Task<IData> QueryXmiDataAsync(XmlReader xmiReader, IXmiDataCache xmiDataC
 
             if (this.readerAsyncCache.TryGetValue(xsiType, out var readerFactory))
             {
-                return readerFactory(xmiDataCache, externalReferenceService, loggerFactory, xmiReader, currentLocation);
+                return readerFactory(xmiDataCache, externalReferenceService, loggerFactory, xmiReader, currentLocation, elementOriginMap);
             }
 
             throw new InvalidOperationException($"No reader found for xsi:type - {xsiType}");
diff --git a/SysML2.NET.Serializer.Xmi/Readers/IXmiDataReaderFacade.cs b/SysML2.NET.Serializer.Xmi/Readers/IXmiDataReaderFacade.cs
index 9ea0b5cfa..1e1c8e6f6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/IXmiDataReaderFacade.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/IXmiDataReaderFacade.cs
@@ -44,9 +44,10 @@ public interface IXmiDataReaderFacade
         /// <param name="externalReferenceService">The <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The <see cref="ILoggerFactory"/> used to set up logging</param>
         /// <param name="explicitTypeName">The explicit type name to resolve, in case of un-specified xsi:type</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         /// <returns>An instance of the read <see cref="IData"/></returns>
         /// <exception cref="InvalidOperationException">If the xsi:type is not supported</exception>
-        IData QueryXmiData(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "");
+        IData QueryXmiData(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "", IXmiElementOriginMap elementOriginMap = null);
 
         /// <summary>
         /// Queries asynchronously an instance of an <see cref="IData" /> based on the position of the <see cref="XmlReader"/>.
@@ -59,8 +60,9 @@ public interface IXmiDataReaderFacade
         /// <param name="externalReferenceService">The <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The <see cref="ILoggerFactory"/> used to set up logging</param>
         /// <param name="explicitTypeName">The explicit type name to resolve, in case of un-specified xsi:type</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         /// <returns>An awaitable <see cref="Task" /> with the instance of the read <see cref="IData"/></returns>
         /// <exception cref="InvalidOperationException">If the xsi:type is not supported</exception>
-        Task<IData> QueryXmiDataAsync(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "");
+        Task<IData> QueryXmiDataAsync(XmlReader xmiReader, IXmiDataCache xmiDataCache, Uri currentLocation, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, string explicitTypeName = "", IXmiElementOriginMap elementOriginMap = null);
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/XmiDataReader.cs b/SysML2.NET.Serializer.Xmi/Readers/XmiDataReader.cs
index cb1554f4e..02ed4305c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/XmiDataReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/XmiDataReader.cs
@@ -54,6 +54,11 @@ public abstract class XmiDataReader<TData> where TData : IData
         /// </summary>
         protected readonly IExternalReferenceService ExternalReferenceService;
 
+        /// <summary>
+        /// The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations
+        /// </summary>
+        protected readonly IXmiElementOriginMap ElementOriginMap;
+
         /// <summary>
         /// the character used to split the values (of xml attributes) using a white space as separator
         /// </summary>
@@ -69,12 +74,14 @@ public abstract class XmiDataReader<TData> where TData : IData
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        protected XmiDataReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        protected XmiDataReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null)
         {
             this.LoggerFactory = loggerFactory;
             this.XmiDataReaderFacade = xmiDataReaderFacade;
             this.Cache = cache;
             this.ExternalReferenceService = externalReferenceService;
+            this.ElementOriginMap = elementOriginMap;
         }
 
         /// <summary>
diff --git a/SysML2.NET.Serializer.Xmi/Serializer.cs b/SysML2.NET.Serializer.Xmi/Serializer.cs
index 03bf985a3..d620da24e 100644
--- a/SysML2.NET.Serializer.Xmi/Serializer.cs
+++ b/SysML2.NET.Serializer.Xmi/Serializer.cs
@@ -1,35 +1,40 @@
-// -------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 // <copyright file="Serializer.cs" company="Starion Group S.A.">
-// 
+//
 //   Copyright 2022-2026 Starion Group S.A.
-// 
+//
 //   Licensed under the Apache License, Version 2.0 (the "License");
 //   you may not use this file except in compliance with the License.
 //   You may obtain a copy of the License at
-// 
+//
 //        http://www.apache.org/licenses/LICENSE-2.0
-// 
+//
 //    Unless required by applicable law or agreed to in writing, software
 //    distributed under the License is distributed on an "AS IS" BASIS,
 //    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
-// 
+//
 // </copyright>
 // ------------------------------------------------------------------------------------------------
 
 namespace SysML2.NET.Serializer.Xmi
 {
+    using System;
     using System.Collections.Generic;
     using System.IO;
+    using System.Linq;
     using System.Threading;
     using System.Threading.Tasks;
-    
+    using System.Xml;
+
     using Microsoft.Extensions.Logging;
     using Microsoft.Extensions.Logging.Abstractions;
-    
+
     using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Serializer.Xmi.Writers;
 
     /// <summary>
     /// The purpose of the <see cref="ISerializer"/> is to write an <see cref="INamespace"/>
@@ -37,24 +42,23 @@ namespace SysML2.NET.Serializer.Xmi
     /// </summary>
     public class Serializer : ISerializer
     {
-        /// <summary>
-        /// The injected <see cref="ILogger{Serializer}" /> to produce logs statement
-        /// </summary>
-        private readonly ILogger<Serializer> logger;
+        private const string XmiNamespace = "http://www.omg.org/spec/XMI/20131001";
+        private const string XsiNamespace = "http://www.w3.org/2001/XMLSchema-instance";
+        private const string SysmlNamespace = "https://www.omg.org/spec/SysML/20240201";
 
-        /// <summary>
-        /// The injected <see cref="ILoggerFactory " /> used to set up logging
-        /// </summary>
+        private readonly ILogger<Serializer> logger;
         private readonly ILoggerFactory loggerFactory;
-        
+        private readonly IXmiWriter xmiWriter;
+
         /// <summary>Initializes a new instance of the <see cref="Serializer"></see> class.</summary>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory " /> used to set up logging</param>
         public Serializer(ILoggerFactory loggerFactory)
         {
             this.loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
             this.logger = this.loggerFactory.CreateLogger<Serializer>();
+            this.xmiWriter = new XmiWriter(this.loggerFactory);
         }
-        
+
         /// <summary>
         /// Serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>
         /// </summary>
@@ -69,11 +73,63 @@ public Serializer(ILoggerFactory loggerFactory)
         /// </param>
         public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream)
         {
-            // if the namespace is not an anonymouse namespace, then first create that and make the
-            // provide namespace owned by the anonymouse
-            
-            throw new System.NotImplementedException();
-        }   
+            this.Serialize(@namespace, includeDerivedProperties, stream, null, null);
+        }
+
+        /// <summary>
+        /// Serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>,
+        /// using an origin map for href reconstruction
+        /// </summary>
+        /// <param name="namespace">
+        /// The <see cref="INamespace"/> that shall be serialized
+        /// </param>
+        /// <param name="includeDerivedProperties">
+        /// Asserts that derived properties should also be part of the serialization
+        /// </param>
+        /// <param name="stream">
+        /// The target <see cref="Stream"/>
+        /// </param>
+        /// <param name="elementOriginMap">
+        /// The optional <see cref="IXmiElementOriginMap"/> for href reconstruction
+        /// </param>
+        /// <param name="currentFileUri">
+        /// The optional <see cref="Uri"/> of the current output file for relative href computation
+        /// </param>
+        public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (@namespace == null)
+            {
+                throw new ArgumentNullException(nameof(@namespace));
+            }
+
+            if (stream == null)
+            {
+                throw new ArgumentNullException(nameof(stream));
+            }
+
+            var settings = new XmlWriterSettings
+            {
+                Indent = true,
+                IndentChars = "  ",
+                NewLineChars = "\n",
+                NewLineHandling = NewLineHandling.Replace,
+                OmitXmlDeclaration = false,
+                Encoding = new System.Text.UTF8Encoding(false)
+            };
+
+            using var xmlWriter = XmlWriter.Create(stream, settings);
+
+            this.logger.LogInformation("Starting XMI serialization");
+
+            xmlWriter.WriteStartDocument();
+
+            this.WriteNamespaceElement(xmlWriter, @namespace, includeDerivedProperties, elementOriginMap, currentFileUri);
+
+            xmlWriter.WriteEndDocument();
+            xmlWriter.Flush();
+
+            this.logger.LogInformation("XMI serialization completed");
+        }
 
         /// <summary>
         /// Asynchronously serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>
@@ -92,10 +148,174 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stre
         /// </param>
         public Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, Stream stream, CancellationToken cancellationToken)
         {
-            // if the namespace is not an anonymouse namespace, then first create that and make the
-            // provide namespace owned by the anonymouse
-            
-            throw new System.NotImplementedException();
+            return Task.Run(() => this.Serialize(@namespace, includeDerivedProperties, stream), cancellationToken);
+        }
+
+        /// <summary>
+        /// Serialize an <see cref="INamespace"/> to multiple XMI files based on the element origin map
+        /// </summary>
+        /// <param name="rootNamespace">The root <see cref="INamespace"/> containing all elements</param>
+        /// <param name="elementOriginMap">The <see cref="IXmiElementOriginMap"/> tracking element-to-file associations</param>
+        /// <param name="outputDirectory">The target directory for output files</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        public void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOriginMap, DirectoryInfo outputDirectory, bool includeDerivedProperties)
+        {
+            if (rootNamespace == null)
+            {
+                throw new ArgumentNullException(nameof(rootNamespace));
+            }
+
+            if (elementOriginMap == null)
+            {
+                throw new ArgumentNullException(nameof(elementOriginMap));
+            }
+
+            if (outputDirectory == null)
+            {
+                throw new ArgumentNullException(nameof(outputDirectory));
+            }
+
+            if (!outputDirectory.Exists)
+            {
+                outputDirectory.Create();
+            }
+
+            var sourceFiles = elementOriginMap.GetAllSourceFiles().ToList();
+
+            this.logger.LogInformation("Starting multi-file XMI serialization for {FileCount} files", sourceFiles.Count);
+
+            foreach (var sourceFile in sourceFiles)
+            {
+                var rootNamespaceId = elementOriginMap.GetRootNamespaceId(sourceFile);
+
+                if (rootNamespaceId == Guid.Empty)
+                {
+                    this.logger.LogWarning("No root namespace found for source file {SourceFile}", sourceFile);
+                    continue;
+                }
+
+                // Compute relative path from original source structure
+                var fileName = Path.GetFileName(sourceFile.LocalPath);
+                var outputPath = Path.Combine(outputDirectory.FullName, fileName);
+                var outputUri = new Uri(outputPath);
+
+                this.logger.LogInformation("Writing {FileName}", fileName);
+
+                // Find the namespace POCO for this file's root namespace
+                var fileRootNamespace = FindNamespaceById(rootNamespace, rootNamespaceId);
+
+                if (fileRootNamespace == null)
+                {
+                    this.logger.LogWarning("Could not find namespace with id {NamespaceId} for file {SourceFile}", rootNamespaceId, sourceFile);
+                    continue;
+                }
+
+                using var fileStream = new FileStream(outputPath, FileMode.Create, FileAccess.Write);
+                this.Serialize(fileRootNamespace, includeDerivedProperties, fileStream, elementOriginMap, outputUri);
+            }
+
+            this.logger.LogInformation("Multi-file XMI serialization completed");
+        }
+
+        private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            xmlWriter.WriteStartElement("sysml", "Namespace", SysmlNamespace);
+            xmlWriter.WriteAttributeString("xmlns", "xmi", null, XmiNamespace);
+            xmlWriter.WriteAttributeString("xmlns", "xsi", null, XsiNamespace);
+            xmlWriter.WriteAttributeString("xmi", "id", XmiNamespace, @namespace.Id.ToString());
+
+            // Write scalar properties
+            if (@namespace.AliasIds != null && @namespace.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", @namespace.AliasIds));
+            }
+
+            if (!string.IsNullOrEmpty(@namespace.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", @namespace.DeclaredName);
+            }
+
+            if (!string.IsNullOrEmpty(@namespace.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", @namespace.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrEmpty(@namespace.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", @namespace.ElementId);
+            }
+
+            if (@namespace.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Write owned relationships as child elements
+            if (@namespace.OwnedRelationship != null)
+            {
+                foreach (var relationship in @namespace.OwnedRelationship)
+                {
+                    if (relationship is IData relationshipData)
+                    {
+                        if (elementOriginMap != null && currentFileUri != null)
+                        {
+                            var childSourceFile = elementOriginMap.GetSourceFile(relationshipData.Id);
+
+                            if (childSourceFile != null && childSourceFile != currentFileUri)
+                            {
+                                var relativePath = currentFileUri.MakeRelativeUri(childSourceFile);
+                                var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{relationshipData.Id}";
+
+                                xmlWriter.WriteStartElement("ownedRelationship");
+                                xmlWriter.WriteAttributeString("href", href);
+                                xmlWriter.WriteEndElement();
+                                continue;
+                            }
+                        }
+
+                        this.xmiWriter.Write(xmlWriter, relationshipData, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+
+        private static INamespace FindNamespaceById(INamespace root, Guid id)
+        {
+            if (root.Id == id)
+            {
+                return root;
+            }
+
+            if (root.OwnedRelationship == null)
+            {
+                return null;
+            }
+
+            foreach (var relationship in root.OwnedRelationship)
+            {
+                if (relationship is IElement element)
+                {
+                    if (element.OwnedRelationship != null)
+                    {
+                        foreach (var child in element.OwnedRelationship)
+                        {
+                            if (child is INamespace childNamespace)
+                            {
+                                var found = FindNamespaceById(childNamespace, id);
+
+                                if (found != null)
+                                {
+                                    return found;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return null;
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/IXmiWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/IXmiWriter.cs
new file mode 100644
index 000000000..04db8b586
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/IXmiWriter.cs
@@ -0,0 +1,45 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IXmiWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+
+    /// <summary>
+    /// The purpose of the <see cref="IXmiWriter"/> is to write <see cref="IData"/> instances
+    /// to an <see cref="XmlWriter"/> in XMI format
+    /// </summary>
+    public interface IXmiWriter
+    {
+        /// <summary>
+        /// Writes the specified <see cref="IData"/> as an XMI element
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="data">The <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null);
+    }
+}
diff --git a/SysML2.NET.Serializer.Xmi/Writers/XmiWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/XmiWriter.cs
new file mode 100644
index 000000000..be6da36b5
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/XmiWriter.cs
@@ -0,0 +1,375 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="XmiWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Linq;
+    using System.Reflection;
+    using System.Xml;
+
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Decorators;
+
+    /// <summary>
+    /// The purpose of the <see cref="XmiWriter"/> is to write <see cref="IData"/> instances
+    /// to an <see cref="XmlWriter"/> in XMI format using reflection on the POCO [Property] attributes
+    /// </summary>
+    public class XmiWriter : IXmiWriter
+    {
+        private readonly ILogger<XmiWriter> logger;
+
+        private static readonly Dictionary<Type, List<PropertySerializationInfo>> PropertyCache = new Dictionary<Type, List<PropertySerializationInfo>>();
+        private static readonly object PropertyCacheLock = new object();
+
+        public XmiWriter(ILoggerFactory loggerFactory = null)
+        {
+            this.logger = loggerFactory == null ? NullLogger<XmiWriter>.Instance : loggerFactory.CreateLogger<XmiWriter>();
+        }
+
+        /// <summary>
+        /// Writes the specified <see cref="IData"/> as an XMI element
+        /// </summary>
+        public void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            if (xmlWriter == null)
+            {
+                throw new ArgumentNullException(nameof(xmlWriter));
+            }
+
+            if (data == null)
+            {
+                throw new ArgumentNullException(nameof(data));
+            }
+
+            var typeName = data.GetType().Name;
+
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, $"sysml:{typeName}");
+            xmlWriter.WriteAttributeString("xmi", "id", null, data.Id.ToString());
+
+            var properties = GetSerializationProperties(data.GetType());
+
+            // Write scalar (non-reference) properties as XML attributes
+            foreach (var propInfo in properties)
+            {
+                if (propInfo.IsDerived && !includeDerivedProperties)
+                {
+                    continue;
+                }
+
+                if (propInfo.IsReference)
+                {
+                    continue;
+                }
+
+                this.WriteScalarAttribute(xmlWriter, data, propInfo);
+            }
+
+            // Write reference and containment properties as child elements
+            foreach (var propInfo in properties)
+            {
+                if (propInfo.IsDerived && !includeDerivedProperties)
+                {
+                    continue;
+                }
+
+                if (!propInfo.IsReference)
+                {
+                    continue;
+                }
+
+                this.WriteReferenceElements(xmlWriter, data, propInfo, includeDerivedProperties, elementOriginMap, currentFileUri);
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+
+        private void WriteScalarAttribute(XmlWriter xmlWriter, IData data, PropertySerializationInfo propInfo)
+        {
+            object value;
+
+            try
+            {
+                value = propInfo.PropertyInfo.GetValue(data);
+            }
+            catch (TargetInvocationException)
+            {
+                return;
+            }
+
+            if (value == null)
+            {
+                return;
+            }
+
+            if (propInfo.IsEnumerable)
+            {
+                var enumerable = (IEnumerable)value;
+                var values = new List<string>();
+
+                foreach (var item in enumerable)
+                {
+                    if (item != null)
+                    {
+                        values.Add(FormatScalarValue(item));
+                    }
+                }
+
+                if (values.Count > 0)
+                {
+                    xmlWriter.WriteAttributeString(propInfo.XmiName, string.Join(" ", values));
+                }
+            }
+            else
+            {
+                var formatted = FormatScalarValue(value);
+
+                if (formatted != null && !IsDefaultValue(value, propInfo))
+                {
+                    xmlWriter.WriteAttributeString(propInfo.XmiName, formatted);
+                }
+            }
+        }
+
+        private void WriteReferenceElements(XmlWriter xmlWriter, IData data, PropertySerializationInfo propInfo, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            object value;
+
+            try
+            {
+                value = propInfo.PropertyInfo.GetValue(data);
+            }
+            catch (TargetInvocationException)
+            {
+                return;
+            }
+
+            if (value == null)
+            {
+                return;
+            }
+
+            if (propInfo.IsEnumerable)
+            {
+                var enumerable = (IEnumerable)value;
+
+                foreach (var item in enumerable)
+                {
+                    if (item is IData childData)
+                    {
+                        if (propInfo.IsComposite)
+                        {
+                            this.WriteContainedElement(xmlWriter, childData, propInfo.XmiName, includeDerivedProperties, elementOriginMap, currentFileUri);
+                        }
+                        else
+                        {
+                            this.WriteReferenceElement(xmlWriter, childData, propInfo.XmiName, elementOriginMap, currentFileUri);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                if (value is IData childData)
+                {
+                    if (propInfo.IsComposite)
+                    {
+                        this.WriteContainedElement(xmlWriter, childData, propInfo.XmiName, includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                    else
+                    {
+                        this.WriteReferenceElement(xmlWriter, childData, propInfo.XmiName, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+        }
+
+        private void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (elementOriginMap != null && currentFileUri != null)
+            {
+                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
+
+                if (childSourceFile != null && childSourceFile != currentFileUri)
+                {
+                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    return;
+                }
+            }
+
+            this.Write(xmlWriter, childData, elementName, includeDerivedProperties, elementOriginMap, currentFileUri);
+        }
+
+        private void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (elementOriginMap != null && currentFileUri != null)
+            {
+                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
+
+                if (childSourceFile != null && childSourceFile != currentFileUri)
+                {
+                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    return;
+                }
+            }
+
+            // Same file reference - write as id reference
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xmi", "idref", null, childData.Id.ToString());
+            xmlWriter.WriteEndElement();
+        }
+
+        private static void WriteHrefElement(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile)
+        {
+            var relativePath = currentFile.MakeRelativeUri(targetFile);
+            var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{childData.Id}";
+
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("href", href);
+            xmlWriter.WriteEndElement();
+        }
+
+        private static string FormatScalarValue(object value)
+        {
+            switch (value)
+            {
+                case bool b:
+                    return b ? "true" : "false";
+                case int i:
+                    return i.ToString(CultureInfo.InvariantCulture);
+                case double d:
+                    return d.ToString(CultureInfo.InvariantCulture);
+                case Enum e:
+                    return e.ToString();
+                case string s:
+                    return s;
+                default:
+                    return value.ToString();
+            }
+        }
+
+        private static bool IsDefaultValue(object value, PropertySerializationInfo propInfo)
+        {
+            if (propInfo.DefaultValue == null)
+            {
+                return false;
+            }
+
+            var formatted = FormatScalarValue(value);
+            return string.Equals(formatted, propInfo.DefaultValue, StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static List<PropertySerializationInfo> GetSerializationProperties(Type pocoType)
+        {
+            lock (PropertyCacheLock)
+            {
+                if (PropertyCache.TryGetValue(pocoType, out var cached))
+                {
+                    return cached;
+                }
+
+                var result = new List<PropertySerializationInfo>();
+                var interfaces = pocoType.GetInterfaces();
+
+                var processedNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+                foreach (var iface in interfaces)
+                {
+                    foreach (var prop in iface.GetProperties())
+                    {
+                        var attr = prop.GetCustomAttribute<PropertyAttribute>();
+
+                        if (attr == null)
+                        {
+                            continue;
+                        }
+
+                        var xmiName = char.ToLowerInvariant(prop.Name[0]) + prop.Name.Substring(1);
+
+                        if (!processedNames.Add(xmiName))
+                        {
+                            continue;
+                        }
+
+                        var propType = prop.PropertyType;
+                        var isEnumerable = propType != typeof(string) && typeof(IEnumerable).IsAssignableFrom(propType);
+                        var elementType = isEnumerable ? GetElementType(propType) : propType;
+                        var isReference = elementType != null && typeof(IData).IsAssignableFrom(elementType);
+
+                        // Try to get the property from the concrete type to ensure we can read it
+                        var concreteProp = pocoType.GetProperty(prop.Name) ?? prop;
+
+                        result.Add(new PropertySerializationInfo
+                        {
+                            PropertyInfo = concreteProp,
+                            XmiName = xmiName,
+                            IsDerived = attr.IsDerived,
+                            IsComposite = attr.Aggregation == AggregationKind.Composite,
+                            IsReference = isReference,
+                            IsEnumerable = isEnumerable,
+                            DefaultValue = attr.DefaultValue
+                        });
+                    }
+                }
+
+                PropertyCache[pocoType] = result;
+                return result;
+            }
+        }
+
+        private static Type GetElementType(Type enumerableType)
+        {
+            if (enumerableType.IsGenericType)
+            {
+                return enumerableType.GetGenericArguments().FirstOrDefault();
+            }
+
+            foreach (var iface in enumerableType.GetInterfaces())
+            {
+                if (iface.IsGenericType && iface.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+                {
+                    return iface.GetGenericArguments().FirstOrDefault();
+                }
+            }
+
+            return null;
+        }
+
+        private class PropertySerializationInfo
+        {
+            public PropertyInfo PropertyInfo { get; set; }
+            public string XmiName { get; set; }
+            public bool IsDerived { get; set; }
+            public bool IsComposite { get; set; }
+            public bool IsReference { get; set; }
+            public bool IsEnumerable { get; set; }
+            public string DefaultValue { get; set; }
+        }
+    }
+}
diff --git a/SysML2.NET.Serializer.Xmi/XmiElementOriginMap.cs b/SysML2.NET.Serializer.Xmi/XmiElementOriginMap.cs
new file mode 100644
index 000000000..aa4105de9
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/XmiElementOriginMap.cs
@@ -0,0 +1,101 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="XmiElementOriginMap.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    /// <summary>
+    /// Tracks the association between elements and the XMI source files they were deserialized from.
+    /// </summary>
+    public class XmiElementOriginMap : IXmiElementOriginMap
+    {
+        /// <summary>
+        /// Maps element identifiers to their source file URIs
+        /// </summary>
+        private readonly Dictionary<Guid, Uri> elementToFile = new Dictionary<Guid, Uri>();
+
+        /// <summary>
+        /// Maps source file URIs to their root namespace identifiers
+        /// </summary>
+        private readonly Dictionary<Uri, Guid> fileToRootNamespace = new Dictionary<Uri, Guid>();
+
+        /// <summary>
+        /// Registers the source file for a given element
+        /// </summary>
+        /// <param name="elementId">The <see cref="Guid"/> identifier of the element</param>
+        /// <param name="sourceFile">The <see cref="Uri"/> of the source XMI file</param>
+        public void Register(Guid elementId, Uri sourceFile)
+        {
+            this.elementToFile[elementId] = sourceFile;
+        }
+
+        /// <summary>
+        /// Gets the source file for a given element
+        /// </summary>
+        /// <param name="elementId">The <see cref="Guid"/> identifier of the element</param>
+        /// <returns>The <see cref="Uri"/> of the source file, or null if not tracked</returns>
+        public Uri GetSourceFile(Guid elementId)
+        {
+            return this.elementToFile.TryGetValue(elementId, out var sourceFile) ? sourceFile : null;
+        }
+
+        /// <summary>
+        /// Gets all element identifiers that were deserialized from the given source file
+        /// </summary>
+        /// <param name="sourceFile">The <see cref="Uri"/> of the source XMI file</param>
+        /// <returns>An <see cref="IEnumerable{Guid}"/> of element identifiers</returns>
+        public IEnumerable<Guid> GetElementsInFile(Uri sourceFile)
+        {
+            return this.elementToFile.Where(kvp => kvp.Value == sourceFile).Select(kvp => kvp.Key);
+        }
+
+        /// <summary>
+        /// Gets all source files that have been registered
+        /// </summary>
+        /// <returns>An <see cref="IEnumerable{Uri}"/> of source file URIs</returns>
+        public IEnumerable<Uri> GetAllSourceFiles()
+        {
+            return this.elementToFile.Values.Distinct();
+        }
+
+        /// <summary>
+        /// Registers the root namespace identifier for a given source file
+        /// </summary>
+        /// <param name="sourceFile">The <see cref="Uri"/> of the source XMI file</param>
+        /// <param name="rootNamespaceId">The <see cref="Guid"/> of the root namespace element</param>
+        public void RegisterRootNamespace(Uri sourceFile, Guid rootNamespaceId)
+        {
+            this.fileToRootNamespace[sourceFile] = rootNamespaceId;
+        }
+
+        /// <summary>
+        /// Gets the root namespace identifier for a given source file
+        /// </summary>
+        /// <param name="sourceFile">The <see cref="Uri"/> of the source XMI file</param>
+        /// <returns>The <see cref="Guid"/> of the root namespace, or <see cref="Guid.Empty"/> if not registered</returns>
+        public Guid GetRootNamespaceId(Uri sourceFile)
+        {
+            return this.fileToRootNamespace.TryGetValue(sourceFile, out var rootNamespaceId) ? rootNamespaceId : Guid.Empty;
+        }
+    }
+}

From d1686a72b95b48164528fd788cb65e7406f4b794 Mon Sep 17 00:00:00 2001
From: samatstarion <s.gerene@stariongroup.eu>
Date: Sat, 7 Mar 2026 23:18:02 +0100
Subject: [PATCH 4/9] [Refactor] xmiwriter to generated classes

---
 CLAUDE.md                                     |   5 +
 .../UmlCoreXmiWriterGeneratorTestFixture.cs   |  53 ++
 .../UmlCoreXmiWriterGenerator.cs              |  55 ++
 .../SysML2.NET.CodeGenerator.csproj           |  12 +
 ...mi-writer-partial-for-element-template.hbs |  22 +
 .../Uml/core-xmi-writer-facade-template.hbs   | 150 ++++
 .../Uml/core-xmi-writer-template.hbs          |  24 +-
 SysML2.NET.Serializer.Xmi/Serializer.cs       |   6 +-
 .../AutoGenWriters/AcceptActionUsageWriter.cs | 778 ++++++++++++++++
 .../AutoGenWriters/ActionDefinitionWriter.cs  | 635 +++++++++++++
 .../AutoGenWriters/ActionUsageWriter.cs       | 765 ++++++++++++++++
 .../AutoGenWriters/ActorMembershipWriter.cs   | 217 +++++
 .../AllocationDefinitionWriter.cs             | 661 ++++++++++++++
 .../AutoGenWriters/AllocationUsageWriter.cs   | 818 +++++++++++++++++
 .../AnalysisCaseDefinitionWriter.cs           | 677 ++++++++++++++
 .../AutoGenWriters/AnalysisCaseUsageWriter.cs | 797 +++++++++++++++++
 .../AutoGenWriters/AnnotatingElementWriter.cs | 193 ++++
 .../AutoGenWriters/AnnotationWriter.cs        | 210 +++++
 .../AssertConstraintUsageWriter.cs            | 779 ++++++++++++++++
 .../AssignmentActionUsageWriter.cs            | 778 ++++++++++++++++
 .../AssociationStructureWriter.cs             | 408 +++++++++
 .../AutoGenWriters/AssociationWriter.cs       | 407 +++++++++
 .../AttributeDefinitionWriter.cs              | 617 +++++++++++++
 .../AutoGenWriters/AttributeUsageWriter.cs    | 747 ++++++++++++++++
 .../Writers/AutoGenWriters/BehaviorWriter.cs  | 382 ++++++++
 .../BindingConnectorAsUsageWriter.cs          | 792 +++++++++++++++++
 .../AutoGenWriters/BindingConnectorWriter.cs  | 529 +++++++++++
 .../AutoGenWriters/BooleanExpressionWriter.cs | 504 +++++++++++
 .../CalculationDefinitionWriter.cs            | 658 ++++++++++++++
 .../AutoGenWriters/CalculationUsageWriter.cs  | 778 ++++++++++++++++
 .../AutoGenWriters/CaseDefinitionWriter.cs    | 673 ++++++++++++++
 .../Writers/AutoGenWriters/CaseUsageWriter.cs | 793 +++++++++++++++++
 .../Writers/AutoGenWriters/ClassWriter.cs     | 374 ++++++++
 .../AutoGenWriters/ClassifierWriter.cs        | 373 ++++++++
 .../AutoGenWriters/CollectExpressionWriter.cs | 520 +++++++++++
 .../Writers/AutoGenWriters/CommentWriter.cs   | 201 +++++
 .../AutoGenWriters/ConcernDefinitionWriter.cs | 687 ++++++++++++++
 .../AutoGenWriters/ConcernUsageWriter.cs      | 814 +++++++++++++++++
 .../ConjugatedPortDefinitionWriter.cs         | 624 +++++++++++++
 .../ConjugatedPortTypingWriter.cs             | 209 +++++
 .../AutoGenWriters/ConjugationWriter.cs       | 203 +++++
 .../ConnectionDefinitionWriter.cs             | 654 ++++++++++++++
 .../AutoGenWriters/ConnectionUsageWriter.cs   | 818 +++++++++++++++++
 .../Writers/AutoGenWriters/ConnectorWriter.cs | 529 +++++++++++
 .../ConstraintDefinitionWriter.cs             | 644 ++++++++++++++
 .../AutoGenWriters/ConstraintUsageWriter.cs   | 771 ++++++++++++++++
 .../ConstructorExpressionWriter.cs            | 516 +++++++++++
 .../AutoGenWriters/CrossSubsettingWriter.cs   | 200 +++++
 .../Writers/AutoGenWriters/DataTypeWriter.cs  | 374 ++++++++
 .../AutoGenWriters/DecisionNodeWriter.cs      | 765 ++++++++++++++++
 .../AutoGenWriters/DefinitionWriter.cs        | 616 +++++++++++++
 .../AutoGenWriters/DependencyWriter.cs        | 205 +++++
 .../AutoGenWriters/DifferencingWriter.cs      | 199 +++++
 .../AutoGenWriters/DisjoiningWriter.cs        | 203 +++++
 .../AutoGenWriters/DocumentationWriter.cs     | 198 +++++
 .../ElementFilterMembershipWriter.cs          | 214 +++++
 .../EndFeatureMembershipWriter.cs             | 214 +++++
 .../EnumerationDefinitionWriter.cs            | 616 +++++++++++++
 .../AutoGenWriters/EnumerationUsageWriter.cs  | 744 ++++++++++++++++
 .../EventOccurrenceUsageWriter.cs             | 761 ++++++++++++++++
 .../AutoGenWriters/ExhibitStateUsageWriter.cs | 785 ++++++++++++++++
 .../AutoGenWriters/ExpressionWriter.cs        | 504 +++++++++++
 .../FeatureChainExpressionWriter.cs           | 524 +++++++++++
 .../AutoGenWriters/FeatureChainingWriter.cs   | 199 +++++
 .../AutoGenWriters/FeatureInvertingWriter.cs  | 203 +++++
 .../AutoGenWriters/FeatureMembershipWriter.cs | 214 +++++
 .../FeatureReferenceExpressionWriter.cs       | 509 +++++++++++
 .../AutoGenWriters/FeatureTypingWriter.cs     | 204 +++++
 .../AutoGenWriters/FeatureValueWriter.cs      | 227 +++++
 .../Writers/AutoGenWriters/FeatureWriter.cs   | 490 ++++++++++
 .../AutoGenWriters/FlowDefinitionWriter.cs    | 670 ++++++++++++++
 .../Writers/AutoGenWriters/FlowEndWriter.cs   | 491 ++++++++++
 .../Writers/AutoGenWriters/FlowUsageWriter.cs | 838 ++++++++++++++++++
 .../Writers/AutoGenWriters/FlowWriter.cs      | 558 ++++++++++++
 .../ForLoopActionUsageWriter.cs               | 778 ++++++++++++++++
 .../Writers/AutoGenWriters/ForkNodeWriter.cs  | 765 ++++++++++++++++
 .../FramedConcernMembershipWriter.cs          | 222 +++++
 .../Writers/AutoGenWriters/FunctionWriter.cs  | 397 +++++++++
 .../AutoGenWriters/IfActionUsageWriter.cs     | 778 ++++++++++++++++
 .../IncludeUseCaseUsageWriter.cs              | 804 +++++++++++++++++
 .../AutoGenWriters/IndexExpressionWriter.cs   | 520 +++++++++++
 .../AutoGenWriters/InteractionWriter.cs       | 416 +++++++++
 .../InterfaceDefinitionWriter.cs              | 654 ++++++++++++++
 .../AutoGenWriters/InterfaceUsageWriter.cs    | 818 +++++++++++++++++
 .../AutoGenWriters/IntersectingWriter.cs      | 199 +++++
 .../Writers/AutoGenWriters/InvariantWriter.cs | 508 +++++++++++
 .../InvocationExpressionWriter.cs             | 516 +++++++++++
 .../AutoGenWriters/ItemDefinitionWriter.cs    | 621 +++++++++++++
 .../Writers/AutoGenWriters/ItemUsageWriter.cs | 765 ++++++++++++++++
 .../Writers/AutoGenWriters/JoinNodeWriter.cs  | 765 ++++++++++++++++
 .../AutoGenWriters/LibraryPackageWriter.cs    | 223 +++++
 .../AutoGenWriters/LiteralBooleanWriter.cs    | 509 +++++++++++
 .../AutoGenWriters/LiteralExpressionWriter.cs | 505 +++++++++++
 .../AutoGenWriters/LiteralInfinityWriter.cs   | 505 +++++++++++
 .../AutoGenWriters/LiteralIntegerWriter.cs    | 506 +++++++++++
 .../AutoGenWriters/LiteralRationalWriter.cs   | 506 +++++++++++
 .../AutoGenWriters/LiteralStringWriter.cs     | 509 +++++++++++
 .../AutoGenWriters/MembershipExposeWriter.cs  | 213 +++++
 .../AutoGenWriters/MembershipImportWriter.cs  | 212 +++++
 .../AutoGenWriters/MembershipWriter.cs        | 212 +++++
 .../Writers/AutoGenWriters/MergeNodeWriter.cs | 765 ++++++++++++++++
 .../Writers/AutoGenWriters/MetaclassWriter.cs | 375 ++++++++
 .../MetadataAccessExpressionWriter.cs         | 509 +++++++++++
 .../MetadataDefinitionWriter.cs               | 621 +++++++++++++
 .../AutoGenWriters/MetadataFeatureWriter.cs   | 520 +++++++++++
 .../AutoGenWriters/MetadataUsageWriter.cs     | 795 +++++++++++++++++
 .../AutoGenWriters/MultiplicityRangeWriter.cs | 507 +++++++++++
 .../AutoGenWriters/MultiplicityWriter.cs      | 490 ++++++++++
 .../AutoGenWriters/NamespaceExposeWriter.cs   | 213 +++++
 .../AutoGenWriters/NamespaceImportWriter.cs   | 212 +++++
 .../Writers/AutoGenWriters/NamespaceWriter.cs | 210 +++++
 .../AutoGenWriters/NullExpressionWriter.cs    | 505 +++++++++++
 .../ObjectiveMembershipWriter.cs              | 216 +++++
 .../OccurrenceDefinitionWriter.cs             | 621 +++++++++++++
 .../AutoGenWriters/OccurrenceUsageWriter.cs   | 757 ++++++++++++++++
 .../OperatorExpressionWriter.cs               | 520 +++++++++++
 .../AutoGenWriters/OwningMembershipWriter.cs  | 212 +++++
 .../Writers/AutoGenWriters/PackageWriter.cs   | 219 +++++
 .../ParameterMembershipWriter.cs              | 215 +++++
 .../AutoGenWriters/PartDefinitionWriter.cs    | 620 +++++++++++++
 .../Writers/AutoGenWriters/PartUsageWriter.cs | 772 ++++++++++++++++
 .../AutoGenWriters/PayloadFeatureWriter.cs    | 491 ++++++++++
 .../PerformActionUsageWriter.cs               | 769 ++++++++++++++++
 .../AutoGenWriters/PortConjugationWriter.cs   | 204 +++++
 .../AutoGenWriters/PortDefinitionWriter.cs    | 625 +++++++++++++
 .../Writers/AutoGenWriters/PortUsageWriter.cs | 757 ++++++++++++++++
 .../Writers/AutoGenWriters/PredicateWriter.cs | 397 +++++++++
 .../AutoGenWriters/RedefinitionWriter.cs      | 204 +++++
 .../ReferenceSubsettingWriter.cs              | 200 +++++
 .../AutoGenWriters/ReferenceUsageWriter.cs    | 746 ++++++++++++++++
 .../RenderingDefinitionWriter.cs              | 627 +++++++++++++
 .../AutoGenWriters/RenderingUsageWriter.cs    | 769 ++++++++++++++++
 .../RequirementConstraintMembershipWriter.cs  | 222 +++++
 .../RequirementDefinitionWriter.cs            | 687 ++++++++++++++
 .../AutoGenWriters/RequirementUsageWriter.cs  | 814 +++++++++++++++++
 ...RequirementVerificationMembershipWriter.cs | 223 +++++
 .../ResultExpressionMembershipWriter.cs       | 215 +++++
 .../ReturnParameterMembershipWriter.cs        | 216 +++++
 .../SatisfyRequirementUsageWriter.cs          | 826 +++++++++++++++++
 .../AutoGenWriters/SelectExpressionWriter.cs  | 520 +++++++++++
 .../AutoGenWriters/SendActionUsageWriter.cs   | 778 ++++++++++++++++
 .../AutoGenWriters/SpecializationWriter.cs    | 203 +++++
 .../StakeholderMembershipWriter.cs            | 217 +++++
 .../AutoGenWriters/StateDefinitionWriter.cs   | 658 ++++++++++++++
 .../StateSubactionMembershipWriter.cs         | 218 +++++
 .../AutoGenWriters/StateUsageWriter.cs        | 781 ++++++++++++++++
 .../Writers/AutoGenWriters/StepWriter.cs      | 498 +++++++++++
 .../Writers/AutoGenWriters/StructureWriter.cs | 375 ++++++++
 .../AutoGenWriters/SubclassificationWriter.cs | 204 +++++
 .../AutoGenWriters/SubjectMembershipWriter.cs | 217 +++++
 .../AutoGenWriters/SubsettingWriter.cs        | 204 +++++
 .../AutoGenWriters/SuccessionAsUsageWriter.cs | 792 +++++++++++++++++
 .../SuccessionFlowUsageWriter.cs              | 838 ++++++++++++++++++
 .../AutoGenWriters/SuccessionFlowWriter.cs    | 558 ++++++++++++
 .../AutoGenWriters/SuccessionWriter.cs        | 529 +++++++++++
 .../TerminateActionUsageWriter.cs             | 770 ++++++++++++++++
 .../TextualRepresentationWriter.cs            | 198 +++++
 .../TransitionFeatureMembershipWriter.cs      | 218 +++++
 .../AutoGenWriters/TransitionUsageWriter.cs   | 800 +++++++++++++++++
 .../TriggerInvocationExpressionWriter.cs      | 519 +++++++++++
 .../AutoGenWriters/TypeFeaturingWriter.cs     | 204 +++++
 .../Writers/AutoGenWriters/TypeWriter.cs      | 365 ++++++++
 .../Writers/AutoGenWriters/UnioningWriter.cs  | 199 +++++
 .../Writers/AutoGenWriters/UsageWriter.cs     | 746 ++++++++++++++++
 .../AutoGenWriters/UseCaseDefinitionWriter.cs | 680 ++++++++++++++
 .../AutoGenWriters/UseCaseUsageWriter.cs      | 800 +++++++++++++++++
 .../AutoGenWriters/VariantMembershipWriter.cs | 213 +++++
 .../VerificationCaseDefinitionWriter.cs       | 680 ++++++++++++++
 .../VerificationCaseUsageWriter.cs            | 804 +++++++++++++++++
 .../AutoGenWriters/ViewDefinitionWriter.cs    | 646 ++++++++++++++
 .../ViewRenderingMembershipWriter.cs          | 219 +++++
 .../Writers/AutoGenWriters/ViewUsageWriter.cs | 795 +++++++++++++++++
 .../ViewpointDefinitionWriter.cs              | 694 +++++++++++++++
 .../AutoGenWriters/ViewpointUsageWriter.cs    | 821 +++++++++++++++++
 .../WhileLoopActionUsageWriter.cs             | 778 ++++++++++++++++
 .../AutoGenWriters/XmiDataWriterFacade.cs     | 480 ++++++++++
 .../Writers/IXmiDataWriterFacade.cs           |  66 ++
 .../Writers/IXmiWriter.cs                     |  45 -
 .../Writers/XmiWriter.cs                      | 375 --------
 179 files changed, 86156 insertions(+), 426 deletions(-)
 create mode 100644 SysML2.NET.CodeGenerator.Tests/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGeneratorTestFixture.cs
 create mode 100644 SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs
 create mode 100644 SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs
 delete mode 100644 SysML2.NET.Serializer.Xmi/Writers/IXmiWriter.cs
 delete mode 100644 SysML2.NET.Serializer.Xmi/Writers/XmiWriter.cs

diff --git a/CLAUDE.md b/CLAUDE.md
index bd514d8ac..37377a82e 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -31,6 +31,11 @@ Test framework: **NUnit**. Test classes use `[TestFixture]` and `[Test]` attribu
 
 ## Architecture
 
+### Code Generation
+
+- favour duplicated code in codegeneration to have staticaly defined methods that provide performance over reflection based code.
+- code generation is done by processing the UML model and creating handlebars templates
+
 ### Code Generation Pipeline
 
 Most code in this repo is **auto-generated** — files marked `THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!` must not be edited directly.
diff --git a/SysML2.NET.CodeGenerator.Tests/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGeneratorTestFixture.cs b/SysML2.NET.CodeGenerator.Tests/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGeneratorTestFixture.cs
new file mode 100644
index 000000000..cf6aaa900
--- /dev/null
+++ b/SysML2.NET.CodeGenerator.Tests/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGeneratorTestFixture.cs
@@ -0,0 +1,53 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UmlCoreXmiWriterGeneratorTestFixture.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.CodeGenerator.Tests.Generators.UmlHandleBarsGenerators
+{
+    using System.IO;
+    using System.Threading.Tasks;
+
+    using NUnit.Framework;
+
+    using SysML2.NET.CodeGenerator.Generators.UmlHandleBarsGenerators;
+
+    [TestFixture]
+    public class UmlCoreXmiWriterGeneratorTestFixture
+    {
+        private DirectoryInfo umlXmiWriterDirectoryInfo;
+        private UmlCoreXmiWriterGenerator umlCoreXmiWriterGenerator;
+
+        [OneTimeSetUp]
+        public void OneTimeSetup()
+        {
+            var directoryInfo = new DirectoryInfo(TestContext.CurrentContext.TestDirectory);
+
+            var path = Path.Combine("UML", "_SysML2.NET.Serializer.Xmi.AutoGenWriters");
+
+            this.umlXmiWriterDirectoryInfo = directoryInfo.CreateSubdirectory(path);
+            this.umlCoreXmiWriterGenerator = new UmlCoreXmiWriterGenerator();
+        }
+
+        [Test]
+        public async Task VerifyXmiWritersAreGenerated()
+        {
+            await Assert.ThatAsync(() => this.umlCoreXmiWriterGenerator.GenerateAsync(GeneratorSetupFixture.XmiReaderResult, this.umlXmiWriterDirectoryInfo), Throws.Nothing);
+        }
+    }
+}
diff --git a/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs b/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs
index a76459fb6..17127eea4 100644
--- a/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs
+++ b/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs
@@ -42,6 +42,11 @@ public class UmlCoreXmiWriterGenerator : UmlHandleBarsGenerator
         /// </summary>
         private const string XmiWriterTemplateName = "core-xmi-writer-template";
 
+        /// <summary>
+        /// Gets the name of the Xmi Writer Facade template
+        /// </summary>
+        private const string XmiWriterFacadeTemplateName = "core-xmi-writer-facade-template";
+
         /// <summary>
         /// Generates code specific to the concrete implementation
         /// </summary>
@@ -57,6 +62,7 @@ public class UmlCoreXmiWriterGenerator : UmlHandleBarsGenerator
         public override async Task GenerateAsync(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory)
         {
             await this.GenerateXmiWriters(xmiReaderResult, outputDirectory);
+            await this.GenerateXmiWriterFacade(xmiReaderResult, outputDirectory);
         }
 
         /// <summary>
@@ -111,6 +117,53 @@ private async Task GenerateXmiWritersInternal(XmiReaderResult xmiReaderResult, D
             }
         }
 
+        /// <summary>
+        /// Generates XMI Writer facade class for all concrete <see cref="IClass" />
+        /// </summary>
+        /// <param name="xmiReaderResult">the <see cref="XmiReaderResult" /> that contains the UML model to generate from</param>
+        /// <param name="outputDirectory">
+        /// The target <see cref="DirectoryInfo" />
+        /// </param>
+        /// <returns>
+        /// an awaitable <see cref="Task" />
+        /// </returns>
+        /// <exception cref="ArgumentNullException">
+        /// In case of null value for <paramref name="xmiReaderResult" /> or
+        /// <paramref name="outputDirectory" />
+        /// </exception>
+        private Task GenerateXmiWriterFacade(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory)
+        {
+            ArgumentNullException.ThrowIfNull(xmiReaderResult);
+            ArgumentNullException.ThrowIfNull(outputDirectory);
+
+            return this.GenerateXmiWriterFacadeInternal(xmiReaderResult, outputDirectory);
+        }
+
+        /// <summary>
+        /// Generates XMI Writer facade class for all concrete <see cref="IClass" />
+        /// </summary>
+        /// <param name="xmiReaderResult">the <see cref="XmiReaderResult" /> that contains the UML model to generate from</param>
+        /// <param name="outputDirectory">
+        /// The target <see cref="DirectoryInfo" />
+        /// </param>
+        /// <returns>
+        /// an awaitable <see cref="Task" />
+        /// </returns>
+        private async Task GenerateXmiWriterFacadeInternal(XmiReaderResult xmiReaderResult, DirectoryInfo outputDirectory)
+        {
+            var template = this.Templates[XmiWriterFacadeTemplateName];
+
+            var classes = xmiReaderResult.QueryContainedAndImported("SysML")
+                .SelectMany(x => x.PackagedElement.OfType<IClass>())
+                .Where(x => !x.IsAbstract)
+                .OrderBy(x => x.Name)
+                .ToList();
+
+            var generatedFacade = template(classes);
+            generatedFacade = this.CodeCleanup(generatedFacade);
+            await WriteAsync(generatedFacade, outputDirectory, "XmiDataWriterFacade.cs");
+        }
+
         /// <summary>
         /// Register the custom helpers
         /// </summary>
@@ -131,7 +184,9 @@ protected override void RegisterHelpers()
         protected override void RegisterTemplates()
         {
             this.RegisterTemplate(XmiWriterTemplateName);
+            this.RegisterTemplate(XmiWriterFacadeTemplateName);
             this.RegisterPartialTemplate("core-xmi-writer-partial-for-attribute-template");
+            this.RegisterPartialTemplate("core-xmi-writer-partial-for-element-template");
         }
     }
 }
diff --git a/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj b/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj
index a14690e29..fc0403b0b 100644
--- a/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj
+++ b/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj
@@ -211,6 +211,18 @@
     <None Update="Templates\Uml\core-poco-reference-resolve-extension-facade-template.hbs">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <None Update="Templates\Uml\core-xmi-writer-template.hbs">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="Templates\Uml\core-xmi-writer-facade-template.hbs">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="Templates\Uml\Partials\core-xmi-writer-partial-for-attribute-template.hbs">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="Templates\Uml\Partials\core-xmi-writer-partial-for-element-template.hbs">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Resources\HtmlDocs\" />
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs
new file mode 100644
index 000000000..83ed4836b
--- /dev/null
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs
@@ -0,0 +1,22 @@
+{{#if (Property.QueryIsEnumerable property)}}
+    if(poco.{{Property.WritePropertyName property}} != null)
+    {
+        foreach(var item in poco.{{Property.WritePropertyName property}})
+        {
+            {{#if property.IsComposite}}
+                xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, elementOriginMap, currentFileUri);
+            {{else}}
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
+            {{/if}}
+        }
+    }
+{{else}}
+    if(poco.{{Property.WritePropertyName property}} != null)
+    {
+        {{#if property.IsComposite}}
+            xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, elementOriginMap, currentFileUri);
+        {{else}}
+            xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
+        {{/if}}
+    }
+{{/if}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
new file mode 100644
index 000000000..da497725d
--- /dev/null
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
@@ -0,0 +1,150 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="XmiDataWriterFacade.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="XmiDataWriterFacade"/> is to dispatch writing of <see cref="IData"/> instances
+    /// to the appropriate per-type static writer class
+    /// </summary>
+    public class XmiDataWriterFacade : IXmiDataWriterFacade
+    {
+        /// <summary>
+        /// A dictionary that contains actions that write <see cref="IData"/> based on a key that represents the POCO type name
+        /// </summary>
+        private readonly Dictionary<string, Action<XmlWriter, IData, string, bool, IXmiDataWriterFacade, IXmiElementOriginMap, Uri>> writerCache;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="XmiDataWriterFacade"/>
+        /// </summary>
+        public XmiDataWriterFacade()
+        {
+            this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, bool, IXmiDataWriterFacade, IXmiElementOriginMap, Uri>>
+            {
+            {{ #each this as | class | }}
+                ["{{ class.Name }}"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    {{ class.Name }}Writer.Write(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, includeDerived, facade, originMap, uri),
+            {{/each}}
+            };
+        }
+
+        /// <summary>
+        /// Writes the specified <see cref="IData"/> as an XMI element by dispatching to the appropriate per-type writer
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="data">The <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            var typeName = data.GetType().Name;
+
+            if (this.writerCache.TryGetValue(typeName, out var writer))
+            {
+                writer(xmlWriter, data, elementName, includeDerivedProperties, this, elementOriginMap, currentFileUri);
+            }
+            else
+            {
+                throw new InvalidOperationException($"No writer found for type {typeName}");
+            }
+        }
+
+        /// <summary>
+        /// Writes a contained child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (elementOriginMap != null && currentFileUri != null)
+            {
+                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
+
+                if (childSourceFile != null && childSourceFile != currentFileUri)
+                {
+                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    return;
+                }
+            }
+
+            this.Write(xmlWriter, childData, elementName, includeDerivedProperties, elementOriginMap, currentFileUri);
+        }
+
+        /// <summary>
+        /// Writes a reference child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (elementOriginMap != null && currentFileUri != null)
+            {
+                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
+
+                if (childSourceFile != null && childSourceFile != currentFileUri)
+                {
+                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    return;
+                }
+            }
+
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xmi", "idref", null, childData.Id.ToString());
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Writes an href element for cross-file references
+        /// </summary>
+        private static void WriteHrefElement(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile)
+        {
+            var relativePath = currentFile.MakeRelativeUri(targetFile);
+            var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{childData.Id}";
+
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("href", href);
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
index 74dea0f05..942382b95 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
@@ -48,10 +48,10 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="poco">The <see cref="I{{this.Name}}" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriter">The <see cref="IXmiWriter" /> for writing child elements</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, I{{this.Name}} poco, string elementName, bool includeDerivedProperties, IXmiWriter xmiWriter, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public static void Write(XmlWriter xmlWriter, I{{this.Name}} poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:{{this.Name}}");
@@ -97,7 +97,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
                         {{#unless this.IsDerived}}
                             {{#if (Property.QueryIsReferenceProperty this)}}
                                 {{#unless (Property.IsPropertyRedefinedInClass this class)}}
-                                    // {{Property.WritePropertyName this}} child elements handled by reflection-based XmiWriter
+                                    {{> core-xmi-writer-partial-for-element-template this}}
                                 {{/unless}}
                             {{/if}}
                         {{/unless}}
@@ -105,6 +105,24 @@ namespace SysML2.NET.Serializer.Xmi.Writers
                 {{/each}}
             {{/with}}
 
+            // Derived reference/containment properties as child elements
+            if(includeDerivedProperties)
+            {
+                {{#with this as |class| }}
+                    {{ #each (Class.QueryAllProperties this) as | property | }}
+                        {{#unless this.IsTransient}}
+                            {{#if this.IsDerived}}
+                                {{#if (Property.QueryIsReferenceProperty this)}}
+                                    {{#unless (Property.IsPropertyRedefinedInClass this class)}}
+                                        {{> core-xmi-writer-partial-for-element-template this}}
+                                    {{/unless}}
+                                {{/if}}
+                            {{/if}}
+                        {{/unless}}
+                    {{/each}}
+                {{/with}}
+            }
+
             xmlWriter.WriteEndElement();
         }
     }
diff --git a/SysML2.NET.Serializer.Xmi/Serializer.cs b/SysML2.NET.Serializer.Xmi/Serializer.cs
index d620da24e..689a82a99 100644
--- a/SysML2.NET.Serializer.Xmi/Serializer.cs
+++ b/SysML2.NET.Serializer.Xmi/Serializer.cs
@@ -48,7 +48,7 @@ public class Serializer : ISerializer
 
         private readonly ILogger<Serializer> logger;
         private readonly ILoggerFactory loggerFactory;
-        private readonly IXmiWriter xmiWriter;
+        private readonly IXmiDataWriterFacade xmiWriterFacade;
 
         /// <summary>Initializes a new instance of the <see cref="Serializer"></see> class.</summary>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory " /> used to set up logging</param>
@@ -56,7 +56,7 @@ public Serializer(ILoggerFactory loggerFactory)
         {
             this.loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
             this.logger = this.loggerFactory.CreateLogger<Serializer>();
-            this.xmiWriter = new XmiWriter(this.loggerFactory);
+            this.xmiWriterFacade = new XmiDataWriterFacade();
         }
 
         /// <summary>
@@ -273,7 +273,7 @@ private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, b
                             }
                         }
 
-                        this.xmiWriter.Write(xmlWriter, relationshipData, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.xmiWriterFacade.Write(xmlWriter, relationshipData, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs
new file mode 100644
index 000000000..2c527debd
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs
@@ -0,0 +1,778 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AcceptActionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AcceptActionUsageWriter" /> is to write an instance of <see cref="IAcceptActionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class AcceptActionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAcceptActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAcceptActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AcceptActionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.payloadArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                }
+                if (poco.payloadParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadParameter, "payloadParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.receiverArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs
new file mode 100644
index 000000000..f589f5c7b
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs
@@ -0,0 +1,635 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ActionDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ActionDefinitionWriter" /> is to write an instance of <see cref="IActionDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class ActionDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IActionDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IActionDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IActionDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ActionDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs
new file mode 100644
index 000000000..9e8f73cb7
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs
@@ -0,0 +1,765 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ActionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ActionUsageWriter" /> is to write an instance of <see cref="IActionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class ActionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ActionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs
new file mode 100644
index 000000000..f729cd662
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs
@@ -0,0 +1,217 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ActorMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ActorMembershipWriter" /> is to write an instance of <see cref="IActorMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class ActorMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IActorMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IActorMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IActorMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ActorMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedActorParameter != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedActorParameter, "ownedActorParameter", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs
new file mode 100644
index 000000000..7ba296a0a
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs
@@ -0,0 +1,661 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AllocationDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AllocationDefinitionWriter" /> is to write an instance of <see cref="IAllocationDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class AllocationDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAllocationDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAllocationDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAllocationDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AllocationDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.allocation != null)
+                {
+                    foreach (var item in poco.allocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "allocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectionEnd != null)
+                {
+                    foreach (var item in poco.connectionEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectionEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs
new file mode 100644
index 000000000..d3d7c8bcc
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs
@@ -0,0 +1,818 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AllocationUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AllocationUsageWriter" /> is to write an instance of <see cref="IAllocationUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class AllocationUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAllocationUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAllocationUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAllocationUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AllocationUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.allocationDefinition != null)
+                {
+                    foreach (var item in poco.allocationDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "allocationDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.partDefinition != null)
+                {
+                    foreach (var item in poco.partDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs
new file mode 100644
index 000000000..4a31e2e09
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs
@@ -0,0 +1,677 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AnalysisCaseDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AnalysisCaseDefinitionWriter" /> is to write an instance of <see cref="IAnalysisCaseDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class AnalysisCaseDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAnalysisCaseDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAnalysisCaseDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AnalysisCaseDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.calculation != null)
+                {
+                    foreach (var item in poco.calculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.objectiveRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.resultExpression != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs
new file mode 100644
index 000000000..5d3857349
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs
@@ -0,0 +1,797 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AnalysisCaseUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AnalysisCaseUsageWriter" /> is to write an instance of <see cref="IAnalysisCaseUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class AnalysisCaseUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAnalysisCaseUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAnalysisCaseUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AnalysisCaseUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.analysisCaseDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.analysisCaseDefinition, "analysisCaseDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.objectiveRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.resultExpression != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs
new file mode 100644
index 000000000..00453e86e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs
@@ -0,0 +1,193 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AnnotatingElementWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AnnotatingElementWriter" /> is to write an instance of <see cref="IAnnotatingElement" />
+    /// to the XMI document
+    /// </summary>
+    public static class AnnotatingElementWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAnnotatingElement" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAnnotatingElement" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AnnotatingElement");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.annotatedElement != null)
+                {
+                    foreach (var item in poco.annotatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs
new file mode 100644
index 000000000..290679907
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs
@@ -0,0 +1,210 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AnnotationWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AnnotationWriter" /> is to write an instance of <see cref="IAnnotation" />
+    /// to the XMI document
+    /// </summary>
+    public static class AnnotationWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAnnotation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAnnotation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAnnotation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Annotation");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.AnnotatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.AnnotatedElement, "annotatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.annotatingElement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.annotatingElement, "annotatingElement", elementOriginMap, currentFileUri);
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotatingElement != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedAnnotatingElement, "ownedAnnotatingElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningAnnotatedElement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatedElement, "owningAnnotatedElement", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningAnnotatingElement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingElement, "owningAnnotatingElement", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs
new file mode 100644
index 000000000..50727dd58
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs
@@ -0,0 +1,779 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AssertConstraintUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AssertConstraintUsageWriter" /> is to write an instance of <see cref="IAssertConstraintUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class AssertConstraintUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAssertConstraintUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAssertConstraintUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AssertConstraintUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsNegated)
+            {
+                xmlWriter.WriteAttributeString("isNegated", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.assertedConstraint != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.assertedConstraint, "assertedConstraint", elementOriginMap, currentFileUri);
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.constraintDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs
new file mode 100644
index 000000000..226d6ff12
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs
@@ -0,0 +1,778 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AssignmentActionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AssignmentActionUsageWriter" /> is to write an instance of <see cref="IAssignmentActionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class AssignmentActionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAssignmentActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAssignmentActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AssignmentActionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.referent != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetArgument, "targetArgument", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.valueExpression != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.valueExpression, "valueExpression", elementOriginMap, currentFileUri);
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs
new file mode 100644
index 000000000..b2c1a9bf0
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs
@@ -0,0 +1,408 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AssociationStructureWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AssociationStructureWriter" /> is to write an instance of <see cref="IAssociationStructure" />
+    /// to the XMI document
+    /// </summary>
+    public static class AssociationStructureWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAssociationStructure" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAssociationStructure" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAssociationStructure poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AssociationStructure");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.associationEnd != null)
+                {
+                    foreach (var item in poco.associationEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs
new file mode 100644
index 000000000..8dfadb206
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs
@@ -0,0 +1,407 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AssociationWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AssociationWriter" /> is to write an instance of <see cref="IAssociation" />
+    /// to the XMI document
+    /// </summary>
+    public static class AssociationWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAssociation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAssociation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAssociation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Association");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.associationEnd != null)
+                {
+                    foreach (var item in poco.associationEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs
new file mode 100644
index 000000000..9439df2cb
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs
@@ -0,0 +1,617 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AttributeDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.DataTypes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AttributeDefinitionWriter" /> is to write an instance of <see cref="IAttributeDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class AttributeDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAttributeDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAttributeDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAttributeDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AttributeDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs
new file mode 100644
index 000000000..3ec3e9556
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs
@@ -0,0 +1,747 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="AttributeUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.DataTypes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="AttributeUsageWriter" /> is to write an instance of <see cref="IAttributeUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class AttributeUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IAttributeUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAttributeUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IAttributeUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AttributeUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.attributeDefinition != null)
+                {
+                    foreach (var item in poco.attributeDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "attributeDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs
new file mode 100644
index 000000000..fc52a5ef0
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs
@@ -0,0 +1,382 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="BehaviorWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="BehaviorWriter" /> is to write an instance of <see cref="IBehavior" />
+    /// to the XMI document
+    /// </summary>
+    public static class BehaviorWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IBehavior" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IBehavior" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IBehavior poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Behavior");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs
new file mode 100644
index 000000000..04c26f13f
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs
@@ -0,0 +1,792 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="BindingConnectorAsUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="BindingConnectorAsUsageWriter" /> is to write an instance of <see cref="IBindingConnectorAsUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class BindingConnectorAsUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IBindingConnectorAsUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IBindingConnectorAsUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:BindingConnectorAsUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.association != null)
+                {
+                    foreach (var item in poco.association)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.definition != null)
+                {
+                    foreach (var item in poco.definition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs
new file mode 100644
index 000000000..ac7adda90
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs
@@ -0,0 +1,529 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="BindingConnectorWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="BindingConnectorWriter" /> is to write an instance of <see cref="IBindingConnector" />
+    /// to the XMI document
+    /// </summary>
+    public static class BindingConnectorWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IBindingConnector" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IBindingConnector" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IBindingConnector poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:BindingConnector");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.association != null)
+                {
+                    foreach (var item in poco.association)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs
new file mode 100644
index 000000000..1452894a2
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs
@@ -0,0 +1,504 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="BooleanExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="BooleanExpressionWriter" /> is to write an instance of <see cref="IBooleanExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class BooleanExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IBooleanExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IBooleanExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IBooleanExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:BooleanExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.predicate != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs
new file mode 100644
index 000000000..5d060e0e1
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs
@@ -0,0 +1,658 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CalculationDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="CalculationDefinitionWriter" /> is to write an instance of <see cref="ICalculationDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class CalculationDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ICalculationDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICalculationDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ICalculationDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CalculationDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.calculation != null)
+                {
+                    foreach (var item in poco.calculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs
new file mode 100644
index 000000000..dbe6e2d82
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs
@@ -0,0 +1,778 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CalculationUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="CalculationUsageWriter" /> is to write an instance of <see cref="ICalculationUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class CalculationUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ICalculationUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICalculationUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ICalculationUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CalculationUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.calculationDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.calculationDefinition, "calculationDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs
new file mode 100644
index 000000000..a671aedd9
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs
@@ -0,0 +1,673 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CaseDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="CaseDefinitionWriter" /> is to write an instance of <see cref="ICaseDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class CaseDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ICaseDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICaseDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ICaseDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CaseDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.calculation != null)
+                {
+                    foreach (var item in poco.calculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.objectiveRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs
new file mode 100644
index 000000000..af56d53eb
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs
@@ -0,0 +1,793 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CaseUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="CaseUsageWriter" /> is to write an instance of <see cref="ICaseUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class CaseUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ICaseUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICaseUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CaseUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.caseDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.objectiveRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs
new file mode 100644
index 000000000..4df80763e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs
@@ -0,0 +1,374 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ClassWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ClassWriter" /> is to write an instance of <see cref="IClass" />
+    /// to the XMI document
+    /// </summary>
+    public static class ClassWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IClass" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IClass" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IClass poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Class");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs
new file mode 100644
index 000000000..8214dcbb8
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs
@@ -0,0 +1,373 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ClassifierWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ClassifierWriter" /> is to write an instance of <see cref="IClassifier" />
+    /// to the XMI document
+    /// </summary>
+    public static class ClassifierWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IClassifier" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IClassifier" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IClassifier poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Classifier");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs
new file mode 100644
index 000000000..a555c9e08
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs
@@ -0,0 +1,520 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CollectExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="CollectExpressionWriter" /> is to write an instance of <see cref="ICollectExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class CollectExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ICollectExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICollectExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ICollectExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CollectExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                xmlWriter.WriteAttributeString("operator", poco.Operator);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.instantiatedType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs
new file mode 100644
index 000000000..5244eb67d
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs
@@ -0,0 +1,201 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CommentWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="CommentWriter" /> is to write an instance of <see cref="IComment" />
+    /// to the XMI document
+    /// </summary>
+    public static class CommentWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IComment" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IComment" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IComment poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Comment");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Body))
+            {
+                xmlWriter.WriteAttributeString("body", poco.Body);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Locale))
+            {
+                xmlWriter.WriteAttributeString("locale", poco.Locale);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.annotatedElement != null)
+                {
+                    foreach (var item in poco.annotatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs
new file mode 100644
index 000000000..0515c36e4
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs
@@ -0,0 +1,687 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConcernDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConcernDefinitionWriter" /> is to write an instance of <see cref="IConcernDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConcernDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConcernDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConcernDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConcernDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConcernDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs
new file mode 100644
index 000000000..154e035ee
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs
@@ -0,0 +1,814 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConcernUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConcernUsageWriter" /> is to write an instance of <see cref="IConcernUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConcernUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConcernUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConcernUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConcernUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConcernUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.concernDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.concernDefinition, "concernDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs
new file mode 100644
index 000000000..b252912cf
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs
@@ -0,0 +1,624 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConjugatedPortDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConjugatedPortDefinitionWriter" /> is to write an instance of <see cref="IConjugatedPortDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConjugatedPortDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConjugatedPortDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConjugatedPortDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConjugatedPortDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.conjugatedPortDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.originalPortDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.originalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPortConjugator != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ownedPortConjugator, "ownedPortConjugator", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs
new file mode 100644
index 000000000..2a81d9c05
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs
@@ -0,0 +1,209 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConjugatedPortTypingWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConjugatedPortTypingWriter" /> is to write an instance of <see cref="IConjugatedPortTyping" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConjugatedPortTypingWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConjugatedPortTyping" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConjugatedPortTyping" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConjugatedPortTyping");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.ConjugatedPortDefinition != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+            if (poco.TypedFeature != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.portDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.portDefinition, "portDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs
new file mode 100644
index 000000000..12d427ca5
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs
@@ -0,0 +1,203 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConjugationWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConjugationWriter" /> is to write an instance of <see cref="IConjugation" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConjugationWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConjugation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConjugation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConjugation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Conjugation");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.ConjugatedType != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+            }
+            if (poco.OriginalType != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OriginalType, "originalType", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs
new file mode 100644
index 000000000..46d88fa24
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs
@@ -0,0 +1,654 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConnectionDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConnectionDefinitionWriter" /> is to write an instance of <see cref="IConnectionDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConnectionDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConnectionDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConnectionDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConnectionDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConnectionDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.connectionEnd != null)
+                {
+                    foreach (var item in poco.connectionEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectionEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs
new file mode 100644
index 000000000..2bdc532f9
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs
@@ -0,0 +1,818 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConnectionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConnectionUsageWriter" /> is to write an instance of <see cref="IConnectionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConnectionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConnectionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConnectionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConnectionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConnectionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectionDefinition != null)
+                {
+                    foreach (var item in poco.connectionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.partDefinition != null)
+                {
+                    foreach (var item in poco.partDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs
new file mode 100644
index 000000000..1db4cdd47
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs
@@ -0,0 +1,529 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConnectorWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConnectorWriter" /> is to write an instance of <see cref="IConnector" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConnectorWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConnector" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConnector" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConnector poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Connector");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.association != null)
+                {
+                    foreach (var item in poco.association)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs
new file mode 100644
index 000000000..6224eaa14
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs
@@ -0,0 +1,644 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConstraintDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConstraintDefinitionWriter" /> is to write an instance of <see cref="IConstraintDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConstraintDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConstraintDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConstraintDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConstraintDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConstraintDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs
new file mode 100644
index 000000000..8d6f3c985
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs
@@ -0,0 +1,771 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConstraintUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConstraintUsageWriter" /> is to write an instance of <see cref="IConstraintUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConstraintUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConstraintUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConstraintUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConstraintUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConstraintUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.constraintDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs
new file mode 100644
index 000000000..4a39a5e6e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs
@@ -0,0 +1,516 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ConstructorExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ConstructorExpressionWriter" /> is to write an instance of <see cref="IConstructorExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class ConstructorExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IConstructorExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConstructorExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IConstructorExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConstructorExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.instantiatedType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs
new file mode 100644
index 000000000..bcff68f7d
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs
@@ -0,0 +1,200 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="CrossSubsettingWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="CrossSubsettingWriter" /> is to write an instance of <see cref="ICrossSubsetting" />
+    /// to the XMI document
+    /// </summary>
+    public static class CrossSubsettingWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ICrossSubsetting" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICrossSubsetting" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CrossSubsetting");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.CrossedFeature != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.CrossedFeature, "crossedFeature", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.crossingFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossingFeature, "crossingFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs
new file mode 100644
index 000000000..69d6e4146
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs
@@ -0,0 +1,374 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DataTypeWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.DataTypes;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="DataTypeWriter" /> is to write an instance of <see cref="IDataType" />
+    /// to the XMI document
+    /// </summary>
+    public static class DataTypeWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IDataType" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDataType" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IDataType poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:DataType");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs
new file mode 100644
index 000000000..5b980db8b
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs
@@ -0,0 +1,765 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DecisionNodeWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="DecisionNodeWriter" /> is to write an instance of <see cref="IDecisionNode" />
+    /// to the XMI document
+    /// </summary>
+    public static class DecisionNodeWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IDecisionNode" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDecisionNode" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IDecisionNode poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:DecisionNode");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs
new file mode 100644
index 000000000..71002c545
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs
@@ -0,0 +1,616 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="DefinitionWriter" /> is to write an instance of <see cref="IDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class DefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Definition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs
new file mode 100644
index 000000000..c18d81ba9
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs
@@ -0,0 +1,205 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DependencyWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Dependencies;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="DependencyWriter" /> is to write an instance of <see cref="IDependency" />
+    /// to the XMI document
+    /// </summary>
+    public static class DependencyWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IDependency" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDependency" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IDependency poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Dependency");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.Client != null)
+            {
+                foreach (var item in poco.Client)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "client", elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+            if (poco.Supplier != null)
+            {
+                foreach (var item in poco.Supplier)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "supplier", elementOriginMap, currentFileUri);
+                }
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs
new file mode 100644
index 000000000..b1d5337f4
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs
@@ -0,0 +1,199 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DifferencingWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="DifferencingWriter" /> is to write an instance of <see cref="IDifferencing" />
+    /// to the XMI document
+    /// </summary>
+    public static class DifferencingWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IDifferencing" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDifferencing" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IDifferencing poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Differencing");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.DifferencingType != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.DifferencingType, "differencingType", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.typeDifferenced != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeDifferenced, "typeDifferenced", elementOriginMap, currentFileUri);
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs
new file mode 100644
index 000000000..5227ed94a
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs
@@ -0,0 +1,203 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DisjoiningWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="DisjoiningWriter" /> is to write an instance of <see cref="IDisjoining" />
+    /// to the XMI document
+    /// </summary>
+    public static class DisjoiningWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IDisjoining" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDisjoining" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IDisjoining poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Disjoining");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.DisjoiningType != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.DisjoiningType, "disjoiningType", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+            if (poco.TypeDisjoined != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypeDisjoined, "typeDisjoined", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs
new file mode 100644
index 000000000..62c925d72
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs
@@ -0,0 +1,198 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DocumentationWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="DocumentationWriter" /> is to write an instance of <see cref="IDocumentation" />
+    /// to the XMI document
+    /// </summary>
+    public static class DocumentationWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IDocumentation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDocumentation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IDocumentation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Documentation");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Body))
+            {
+                xmlWriter.WriteAttributeString("body", poco.Body);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Locale))
+            {
+                xmlWriter.WriteAttributeString("locale", poco.Locale);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentedElement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.documentedElement, "documentedElement", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs
new file mode 100644
index 000000000..94afe6758
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs
@@ -0,0 +1,214 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ElementFilterMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Packages;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ElementFilterMembershipWriter" /> is to write an instance of <see cref="IElementFilterMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class ElementFilterMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IElementFilterMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IElementFilterMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IElementFilterMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ElementFilterMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.condition != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.condition, "condition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membershipOwningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs
new file mode 100644
index 000000000..2dd6a8ec7
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs
@@ -0,0 +1,214 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="EndFeatureMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="EndFeatureMembershipWriter" /> is to write an instance of <see cref="IEndFeatureMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class EndFeatureMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IEndFeatureMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IEndFeatureMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EndFeatureMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMemberFeature != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs
new file mode 100644
index 000000000..0be12857d
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs
@@ -0,0 +1,616 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="EnumerationDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="EnumerationDefinitionWriter" /> is to write an instance of <see cref="IEnumerationDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class EnumerationDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IEnumerationDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IEnumerationDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EnumerationDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.enumeratedValue != null)
+                {
+                    foreach (var item in poco.enumeratedValue)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "enumeratedValue", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs
new file mode 100644
index 000000000..3230b8509
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs
@@ -0,0 +1,744 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="EnumerationUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.DataTypes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="EnumerationUsageWriter" /> is to write an instance of <see cref="IEnumerationUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class EnumerationUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IEnumerationUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IEnumerationUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EnumerationUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.enumerationDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.enumerationDefinition, "enumerationDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs
new file mode 100644
index 000000000..990263f20
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs
@@ -0,0 +1,761 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="EventOccurrenceUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="EventOccurrenceUsageWriter" /> is to write an instance of <see cref="IEventOccurrenceUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class EventOccurrenceUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IEventOccurrenceUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IEventOccurrenceUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EventOccurrenceUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.eventOccurrence != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.eventOccurrence, "eventOccurrence", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs
new file mode 100644
index 000000000..cd7a0bc9e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs
@@ -0,0 +1,785 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ExhibitStateUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ExhibitStateUsageWriter" /> is to write an instance of <see cref="IExhibitStateUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class ExhibitStateUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IExhibitStateUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IExhibitStateUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ExhibitStateUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsParallel)
+            {
+                xmlWriter.WriteAttributeString("isParallel", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.doAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.entryAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.exhibitedState != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exhibitedState, "exhibitedState", elementOriginMap, currentFileUri);
+                }
+                if (poco.exitAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.stateDefinition != null)
+                {
+                    foreach (var item in poco.stateDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stateDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs
new file mode 100644
index 000000000..3c2d27291
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs
@@ -0,0 +1,504 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ExpressionWriter" /> is to write an instance of <see cref="IExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class ExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Expression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs
new file mode 100644
index 000000000..407bcec76
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs
@@ -0,0 +1,524 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureChainExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FeatureChainExpressionWriter" /> is to write an instance of <see cref="IFeatureChainExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class FeatureChainExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFeatureChainExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureChainExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureChainExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                xmlWriter.WriteAttributeString("operator", poco.Operator);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.instantiatedType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetFeature, "targetFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs
new file mode 100644
index 000000000..41118a19c
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs
@@ -0,0 +1,199 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureChainingWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FeatureChainingWriter" /> is to write an instance of <see cref="IFeatureChaining" />
+    /// to the XMI document
+    /// </summary>
+    public static class FeatureChainingWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFeatureChaining" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureChaining" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFeatureChaining poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureChaining");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.ChainingFeature != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ChainingFeature, "chainingFeature", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureChained != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureChained, "featureChained", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs
new file mode 100644
index 000000000..8c9184a16
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs
@@ -0,0 +1,203 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureInvertingWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FeatureInvertingWriter" /> is to write an instance of <see cref="IFeatureInverting" />
+    /// to the XMI document
+    /// </summary>
+    public static class FeatureInvertingWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFeatureInverting" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureInverting" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFeatureInverting poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureInverting");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.FeatureInverted != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeatureInverted, "featureInverted", elementOriginMap, currentFileUri);
+            }
+            if (poco.InvertingFeature != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.InvertingFeature, "invertingFeature", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs
new file mode 100644
index 000000000..0325e0fe0
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs
@@ -0,0 +1,214 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FeatureMembershipWriter" /> is to write an instance of <see cref="IFeatureMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class FeatureMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFeatureMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFeatureMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMemberFeature != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs
new file mode 100644
index 000000000..6c15f7f18
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs
@@ -0,0 +1,509 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureReferenceExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FeatureReferenceExpressionWriter" /> is to write an instance of <see cref="IFeatureReferenceExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class FeatureReferenceExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFeatureReferenceExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureReferenceExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureReferenceExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.referent != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs
new file mode 100644
index 000000000..70c5d32e2
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs
@@ -0,0 +1,204 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureTypingWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FeatureTypingWriter" /> is to write an instance of <see cref="IFeatureTyping" />
+    /// to the XMI document
+    /// </summary>
+    public static class FeatureTypingWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFeatureTyping" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureTyping" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureTyping");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+            if (poco.Type != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Type, "type", elementOriginMap, currentFileUri);
+            }
+            if (poco.TypedFeature != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs
new file mode 100644
index 000000000..9bf133964
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs
@@ -0,0 +1,227 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureValueWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.FeatureValues;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FeatureValueWriter" /> is to write an instance of <see cref="IFeatureValue" />
+    /// to the XMI document
+    /// </summary>
+    public static class FeatureValueWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFeatureValue" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureValue" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFeatureValue poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureValue");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsDefault)
+            {
+                xmlWriter.WriteAttributeString("isDefault", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsInitial)
+            {
+                xmlWriter.WriteAttributeString("isInitial", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureWithValue != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureWithValue, "featureWithValue", elementOriginMap, currentFileUri);
+                }
+                if (poco.membershipOwningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.value != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.value, "value", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs
new file mode 100644
index 000000000..6122909b7
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs
@@ -0,0 +1,490 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FeatureWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FeatureWriter" /> is to write an instance of <see cref="IFeature" />
+    /// to the XMI document
+    /// </summary>
+    public static class FeatureWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFeature" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeature" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFeature poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Feature");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs
new file mode 100644
index 000000000..094081cc5
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs
@@ -0,0 +1,670 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FlowDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FlowDefinitionWriter" /> is to write an instance of <see cref="IFlowDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class FlowDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFlowDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFlowDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFlowDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FlowDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.flowEnd != null)
+                {
+                    foreach (var item in poco.flowEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs
new file mode 100644
index 000000000..ea28d979b
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs
@@ -0,0 +1,491 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FlowEndWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FlowEndWriter" /> is to write an instance of <see cref="IFlowEnd" />
+    /// to the XMI document
+    /// </summary>
+    public static class FlowEndWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFlowEnd" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFlowEnd" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FlowEnd");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs
new file mode 100644
index 000000000..d259a96e1
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs
@@ -0,0 +1,838 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FlowUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FlowUsageWriter" /> is to write an instance of <see cref="IFlowUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class FlowUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFlowUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFlowUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FlowUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.flowDefinition != null)
+                {
+                    foreach (var item in poco.flowDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.flowEnd != null)
+                {
+                    foreach (var item in poco.flowEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.payloadFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.payloadType != null)
+                {
+                    foreach (var item in poco.payloadType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.sourceOutputFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.targetInputFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs
new file mode 100644
index 000000000..a5fbfcbf0
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs
@@ -0,0 +1,558 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FlowWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FlowWriter" /> is to write an instance of <see cref="IFlow" />
+    /// to the XMI document
+    /// </summary>
+    public static class FlowWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFlow" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFlow" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFlow poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Flow");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.flowEnd != null)
+                {
+                    foreach (var item in poco.flowEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.interaction != null)
+                {
+                    foreach (var item in poco.interaction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interaction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.payloadFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.payloadType != null)
+                {
+                    foreach (var item in poco.payloadType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.sourceOutputFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.targetInputFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs
new file mode 100644
index 000000000..8736aa640
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs
@@ -0,0 +1,778 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ForLoopActionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ForLoopActionUsageWriter" /> is to write an instance of <see cref="IForLoopActionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class ForLoopActionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IForLoopActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IForLoopActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ForLoopActionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.bodyAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.loopVariable != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.loopVariable, "loopVariable", elementOriginMap, currentFileUri);
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.seqArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.seqArgument, "seqArgument", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs
new file mode 100644
index 000000000..b1829e891
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs
@@ -0,0 +1,765 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ForkNodeWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ForkNodeWriter" /> is to write an instance of <see cref="IForkNode" />
+    /// to the XMI document
+    /// </summary>
+    public static class ForkNodeWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IForkNode" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IForkNode" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IForkNode poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ForkNode");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs
new file mode 100644
index 000000000..3d9e637dd
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs
@@ -0,0 +1,222 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FramedConcernMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FramedConcernMembershipWriter" /> is to write an instance of <see cref="IFramedConcernMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class FramedConcernMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFramedConcernMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFramedConcernMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FramedConcernMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConcern, "ownedConcern", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.referencedConcern != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedConcern, "referencedConcern", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs
new file mode 100644
index 000000000..7b63a1953
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs
@@ -0,0 +1,397 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="FunctionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="FunctionWriter" /> is to write an instance of <see cref="IFunction" />
+    /// to the XMI document
+    /// </summary>
+    public static class FunctionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IFunction" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFunction" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IFunction poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Function");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs
new file mode 100644
index 000000000..1ae561e4e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs
@@ -0,0 +1,778 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IfActionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="IfActionUsageWriter" /> is to write an instance of <see cref="IIfActionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class IfActionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IIfActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IIfActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:IfActionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.elseAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.elseAction, "elseAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ifArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ifArgument, "ifArgument", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.thenAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.thenAction, "thenAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs
new file mode 100644
index 000000000..67db75402
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs
@@ -0,0 +1,804 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IncludeUseCaseUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="IncludeUseCaseUsageWriter" /> is to write an instance of <see cref="IIncludeUseCaseUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class IncludeUseCaseUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IIncludeUseCaseUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IIncludeUseCaseUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:IncludeUseCaseUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.includedUseCase != null)
+                {
+                    foreach (var item in poco.includedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.objectiveRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.useCaseDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.useCaseIncluded != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseIncluded, "useCaseIncluded", elementOriginMap, currentFileUri);
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs
new file mode 100644
index 000000000..e501f7f79
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs
@@ -0,0 +1,520 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IndexExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="IndexExpressionWriter" /> is to write an instance of <see cref="IIndexExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class IndexExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IIndexExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IIndexExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IIndexExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:IndexExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                xmlWriter.WriteAttributeString("operator", poco.Operator);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.instantiatedType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs
new file mode 100644
index 000000000..fc9537627
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs
@@ -0,0 +1,416 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="InteractionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="InteractionWriter" /> is to write an instance of <see cref="IInteraction" />
+    /// to the XMI document
+    /// </summary>
+    public static class InteractionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IInteraction" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IInteraction" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IInteraction poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Interaction");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.associationEnd != null)
+                {
+                    foreach (var item in poco.associationEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs
new file mode 100644
index 000000000..75c65617c
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs
@@ -0,0 +1,654 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="InterfaceDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="InterfaceDefinitionWriter" /> is to write an instance of <see cref="IInterfaceDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class InterfaceDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IInterfaceDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IInterfaceDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:InterfaceDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.interfaceEnd != null)
+                {
+                    foreach (var item in poco.interfaceEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interfaceEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs
new file mode 100644
index 000000000..8c13792f5
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs
@@ -0,0 +1,818 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="InterfaceUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="InterfaceUsageWriter" /> is to write an instance of <see cref="IInterfaceUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class InterfaceUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IInterfaceUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IInterfaceUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:InterfaceUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.interfaceDefinition != null)
+                {
+                    foreach (var item in poco.interfaceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interfaceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.partDefinition != null)
+                {
+                    foreach (var item in poco.partDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs
new file mode 100644
index 000000000..a75a99dcf
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs
@@ -0,0 +1,199 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IntersectingWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="IntersectingWriter" /> is to write an instance of <see cref="IIntersecting" />
+    /// to the XMI document
+    /// </summary>
+    public static class IntersectingWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IIntersecting" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IIntersecting" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IIntersecting poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Intersecting");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.IntersectingType != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.IntersectingType, "intersectingType", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.typeIntersected != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeIntersected, "typeIntersected", elementOriginMap, currentFileUri);
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs
new file mode 100644
index 000000000..3efd64578
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs
@@ -0,0 +1,508 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="InvariantWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="InvariantWriter" /> is to write an instance of <see cref="IInvariant" />
+    /// to the XMI document
+    /// </summary>
+    public static class InvariantWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IInvariant" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IInvariant" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IInvariant poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Invariant");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsNegated)
+            {
+                xmlWriter.WriteAttributeString("isNegated", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.predicate != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs
new file mode 100644
index 000000000..b1188aea8
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs
@@ -0,0 +1,516 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="InvocationExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="InvocationExpressionWriter" /> is to write an instance of <see cref="IInvocationExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class InvocationExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IInvocationExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IInvocationExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IInvocationExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:InvocationExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.instantiatedType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs
new file mode 100644
index 000000000..be4febcd9
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs
@@ -0,0 +1,621 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ItemDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ItemDefinitionWriter" /> is to write an instance of <see cref="IItemDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class ItemDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IItemDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IItemDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IItemDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ItemDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs
new file mode 100644
index 000000000..b617cff6f
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs
@@ -0,0 +1,765 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ItemUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ItemUsageWriter" /> is to write an instance of <see cref="IItemUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class ItemUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IItemUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IItemUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IItemUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ItemUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs
new file mode 100644
index 000000000..b6feb3b8b
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs
@@ -0,0 +1,765 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="JoinNodeWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="JoinNodeWriter" /> is to write an instance of <see cref="IJoinNode" />
+    /// to the XMI document
+    /// </summary>
+    public static class JoinNodeWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IJoinNode" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IJoinNode" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IJoinNode poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:JoinNode");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs
new file mode 100644
index 000000000..46c596ac5
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs
@@ -0,0 +1,223 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LibraryPackageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Packages;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="LibraryPackageWriter" /> is to write an instance of <see cref="ILibraryPackage" />
+    /// to the XMI document
+    /// </summary>
+    public static class LibraryPackageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ILibraryPackage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILibraryPackage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ILibraryPackage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LibraryPackage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsStandard)
+            {
+                xmlWriter.WriteAttributeString("isStandard", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.filterCondition != null)
+                {
+                    foreach (var item in poco.filterCondition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "filterCondition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs
new file mode 100644
index 000000000..346ed9ee3
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs
@@ -0,0 +1,509 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralBooleanWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="LiteralBooleanWriter" /> is to write an instance of <see cref="ILiteralBoolean" />
+    /// to the XMI document
+    /// </summary>
+    public static class LiteralBooleanWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ILiteralBoolean" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralBoolean" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralBoolean");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+            if (poco.Value)
+            {
+                xmlWriter.WriteAttributeString("value", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs
new file mode 100644
index 000000000..6bd58cf87
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs
@@ -0,0 +1,505 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="LiteralExpressionWriter" /> is to write an instance of <see cref="ILiteralExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class LiteralExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ILiteralExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ILiteralExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs
new file mode 100644
index 000000000..00235584d
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs
@@ -0,0 +1,505 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralInfinityWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="LiteralInfinityWriter" /> is to write an instance of <see cref="ILiteralInfinity" />
+    /// to the XMI document
+    /// </summary>
+    public static class LiteralInfinityWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ILiteralInfinity" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralInfinity" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralInfinity");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs
new file mode 100644
index 000000000..7532b5737
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs
@@ -0,0 +1,506 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralIntegerWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="LiteralIntegerWriter" /> is to write an instance of <see cref="ILiteralInteger" />
+    /// to the XMI document
+    /// </summary>
+    public static class LiteralIntegerWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ILiteralInteger" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralInteger" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ILiteralInteger poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralInteger");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+            xmlWriter.WriteAttributeString("value", poco.Value.ToString(CultureInfo.InvariantCulture));
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs
new file mode 100644
index 000000000..452586c01
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs
@@ -0,0 +1,506 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralRationalWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="LiteralRationalWriter" /> is to write an instance of <see cref="ILiteralRational" />
+    /// to the XMI document
+    /// </summary>
+    public static class LiteralRationalWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ILiteralRational" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralRational" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ILiteralRational poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralRational");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+            xmlWriter.WriteAttributeString("value", poco.Value.ToString(CultureInfo.InvariantCulture));
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs
new file mode 100644
index 000000000..4ca6a580a
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs
@@ -0,0 +1,509 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="LiteralStringWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="LiteralStringWriter" /> is to write an instance of <see cref="ILiteralString" />
+    /// to the XMI document
+    /// </summary>
+    public static class LiteralStringWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ILiteralString" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralString" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ILiteralString poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralString");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Value))
+            {
+                xmlWriter.WriteAttributeString("value", poco.Value);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs
new file mode 100644
index 000000000..48be34bb2
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs
@@ -0,0 +1,213 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MembershipExposeWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MembershipExposeWriter" /> is to write an instance of <see cref="IMembershipExpose" />
+    /// to the XMI document
+    /// </summary>
+    public static class MembershipExposeWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMembershipExpose" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMembershipExpose" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMembershipExpose poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MembershipExpose");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsImportAll)
+            {
+                xmlWriter.WriteAttributeString("isImportAll", "true");
+            }
+            if (poco.IsRecursive)
+            {
+                xmlWriter.WriteAttributeString("isRecursive", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.ImportedMembership != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedElement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                }
+                if (poco.importOwningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs
new file mode 100644
index 000000000..b4fcce4b9
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs
@@ -0,0 +1,212 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MembershipImportWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MembershipImportWriter" /> is to write an instance of <see cref="IMembershipImport" />
+    /// to the XMI document
+    /// </summary>
+    public static class MembershipImportWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMembershipImport" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMembershipImport" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMembershipImport poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MembershipImport");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsImportAll)
+            {
+                xmlWriter.WriteAttributeString("isImportAll", "true");
+            }
+            if (poco.IsRecursive)
+            {
+                xmlWriter.WriteAttributeString("isRecursive", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.ImportedMembership != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedElement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                }
+                if (poco.importOwningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs
new file mode 100644
index 000000000..a8638971e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs
@@ -0,0 +1,212 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MembershipWriter" /> is to write an instance of <see cref="IMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class MembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Membership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.MemberName))
+            {
+                xmlWriter.WriteAttributeString("memberName", poco.MemberName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.MemberShortName))
+            {
+                xmlWriter.WriteAttributeString("memberShortName", poco.MemberShortName);
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.memberElementId))
+                {
+                    xmlWriter.WriteAttributeString("memberElementId", poco.memberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.MemberElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.MemberElement, "memberElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membershipOwningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs
new file mode 100644
index 000000000..98ba6f942
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs
@@ -0,0 +1,765 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MergeNodeWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MergeNodeWriter" /> is to write an instance of <see cref="IMergeNode" />
+    /// to the XMI document
+    /// </summary>
+    public static class MergeNodeWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMergeNode" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMergeNode" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMergeNode poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MergeNode");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs
new file mode 100644
index 000000000..3da79fb27
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs
@@ -0,0 +1,375 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MetaclassWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Metadata;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MetaclassWriter" /> is to write an instance of <see cref="IMetaclass" />
+    /// to the XMI document
+    /// </summary>
+    public static class MetaclassWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMetaclass" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMetaclass" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMetaclass poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Metaclass");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs
new file mode 100644
index 000000000..6d65b6bfb
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs
@@ -0,0 +1,509 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MetadataAccessExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MetadataAccessExpressionWriter" /> is to write an instance of <see cref="IMetadataAccessExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class MetadataAccessExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMetadataAccessExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMetadataAccessExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataAccessExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.referencedElement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedElement, "referencedElement", elementOriginMap, currentFileUri);
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs
new file mode 100644
index 000000000..ed6ffa1c2
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs
@@ -0,0 +1,621 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MetadataDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Metadata;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MetadataDefinitionWriter" /> is to write an instance of <see cref="IMetadataDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class MetadataDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMetadataDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMetadataDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs
new file mode 100644
index 000000000..40f101026
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs
@@ -0,0 +1,520 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MetadataFeatureWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Metadata;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MetadataFeatureWriter" /> is to write an instance of <see cref="IMetadataFeature" />
+    /// to the XMI document
+    /// </summary>
+    public static class MetadataFeatureWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMetadataFeature" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMetadataFeature" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMetadataFeature poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataFeature");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.annotatedElement != null)
+                {
+                    foreach (var item in poco.annotatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.metaclass != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.metaclass, "metaclass", elementOriginMap, currentFileUri);
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs
new file mode 100644
index 000000000..7f6565ab1
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs
@@ -0,0 +1,795 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MetadataUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Metadata;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MetadataUsageWriter" /> is to write an instance of <see cref="IMetadataUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class MetadataUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMetadataUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMetadataUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.annotatedElement != null)
+                {
+                    foreach (var item in poco.annotatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.metadataDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.metadataDefinition, "metadataDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs
new file mode 100644
index 000000000..e3d09bafe
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs
@@ -0,0 +1,507 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MultiplicityRangeWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Multiplicities;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MultiplicityRangeWriter" /> is to write an instance of <see cref="IMultiplicityRange" />
+    /// to the XMI document
+    /// </summary>
+    public static class MultiplicityRangeWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMultiplicityRange" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMultiplicityRange" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MultiplicityRange");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.bound != null)
+                {
+                    foreach (var item in poco.bound)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "bound", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.lowerBound != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.lowerBound, "lowerBound", elementOriginMap, currentFileUri);
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.upperBound != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.upperBound, "upperBound", elementOriginMap, currentFileUri);
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs
new file mode 100644
index 000000000..f446cd931
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs
@@ -0,0 +1,490 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="MultiplicityWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="MultiplicityWriter" /> is to write an instance of <see cref="IMultiplicity" />
+    /// to the XMI document
+    /// </summary>
+    public static class MultiplicityWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IMultiplicity" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMultiplicity" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IMultiplicity poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Multiplicity");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs
new file mode 100644
index 000000000..29847d540
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs
@@ -0,0 +1,213 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="NamespaceExposeWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="NamespaceExposeWriter" /> is to write an instance of <see cref="INamespaceExpose" />
+    /// to the XMI document
+    /// </summary>
+    public static class NamespaceExposeWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="INamespaceExpose" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="INamespaceExpose" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, INamespaceExpose poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:NamespaceExpose");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsImportAll)
+            {
+                xmlWriter.WriteAttributeString("isImportAll", "true");
+            }
+            if (poco.IsRecursive)
+            {
+                xmlWriter.WriteAttributeString("isRecursive", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.ImportedNamespace != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedElement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                }
+                if (poco.importOwningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs
new file mode 100644
index 000000000..a7ce05c96
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs
@@ -0,0 +1,212 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="NamespaceImportWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="NamespaceImportWriter" /> is to write an instance of <see cref="INamespaceImport" />
+    /// to the XMI document
+    /// </summary>
+    public static class NamespaceImportWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="INamespaceImport" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="INamespaceImport" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, INamespaceImport poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:NamespaceImport");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsImportAll)
+            {
+                xmlWriter.WriteAttributeString("isImportAll", "true");
+            }
+            if (poco.IsRecursive)
+            {
+                xmlWriter.WriteAttributeString("isRecursive", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.ImportedNamespace != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedElement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                }
+                if (poco.importOwningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs
new file mode 100644
index 000000000..8b46a3b25
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs
@@ -0,0 +1,210 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="NamespaceWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="NamespaceWriter" /> is to write an instance of <see cref="INamespace" />
+    /// to the XMI document
+    /// </summary>
+    public static class NamespaceWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="INamespace" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="INamespace" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, INamespace poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Namespace");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs
new file mode 100644
index 000000000..f1b08eed8
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs
@@ -0,0 +1,505 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="NullExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="NullExpressionWriter" /> is to write an instance of <see cref="INullExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class NullExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="INullExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="INullExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, INullExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:NullExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs
new file mode 100644
index 000000000..dcda4dcbe
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs
@@ -0,0 +1,216 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ObjectiveMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ObjectiveMembershipWriter" /> is to write an instance of <see cref="IObjectiveMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class ObjectiveMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IObjectiveMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IObjectiveMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IObjectiveMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ObjectiveMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedObjectiveRequirement != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedObjectiveRequirement, "ownedObjectiveRequirement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs
new file mode 100644
index 000000000..254920928
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs
@@ -0,0 +1,621 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="OccurrenceDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="OccurrenceDefinitionWriter" /> is to write an instance of <see cref="IOccurrenceDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class OccurrenceDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IOccurrenceDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IOccurrenceDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OccurrenceDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs
new file mode 100644
index 000000000..0fe2477c0
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs
@@ -0,0 +1,757 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="OccurrenceUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="OccurrenceUsageWriter" /> is to write an instance of <see cref="IOccurrenceUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class OccurrenceUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IOccurrenceUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IOccurrenceUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OccurrenceUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs
new file mode 100644
index 000000000..ab6f7364b
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs
@@ -0,0 +1,520 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="OperatorExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="OperatorExpressionWriter" /> is to write an instance of <see cref="IOperatorExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class OperatorExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IOperatorExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IOperatorExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IOperatorExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OperatorExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                xmlWriter.WriteAttributeString("operator", poco.Operator);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.instantiatedType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs
new file mode 100644
index 000000000..e15b2e27d
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs
@@ -0,0 +1,212 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="OwningMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="OwningMembershipWriter" /> is to write an instance of <see cref="IOwningMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class OwningMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IOwningMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IOwningMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IOwningMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OwningMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membershipOwningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMemberElement != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberElement, "ownedMemberElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs
new file mode 100644
index 000000000..701dfcf99
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs
@@ -0,0 +1,219 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PackageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Packages;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="PackageWriter" /> is to write an instance of <see cref="IPackage" />
+    /// to the XMI document
+    /// </summary>
+    public static class PackageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IPackage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPackage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IPackage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Package");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.filterCondition != null)
+                {
+                    foreach (var item in poco.filterCondition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "filterCondition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs
new file mode 100644
index 000000000..31547ca90
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs
@@ -0,0 +1,215 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ParameterMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ParameterMembershipWriter" /> is to write an instance of <see cref="IParameterMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class ParameterMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IParameterMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IParameterMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IParameterMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ParameterMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMemberParameter != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs
new file mode 100644
index 000000000..204e8a767
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs
@@ -0,0 +1,620 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PartDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="PartDefinitionWriter" /> is to write an instance of <see cref="IPartDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class PartDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IPartDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPartDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IPartDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PartDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs
new file mode 100644
index 000000000..26826aff2
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs
@@ -0,0 +1,772 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PartUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="PartUsageWriter" /> is to write an instance of <see cref="IPartUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class PartUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IPartUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPartUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IPartUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PartUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.partDefinition != null)
+                {
+                    foreach (var item in poco.partDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs
new file mode 100644
index 000000000..0cf7be68e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs
@@ -0,0 +1,491 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PayloadFeatureWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="PayloadFeatureWriter" /> is to write an instance of <see cref="IPayloadFeature" />
+    /// to the XMI document
+    /// </summary>
+    public static class PayloadFeatureWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IPayloadFeature" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPayloadFeature" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IPayloadFeature poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PayloadFeature");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs
new file mode 100644
index 000000000..75e64cf0c
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs
@@ -0,0 +1,769 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PerformActionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="PerformActionUsageWriter" /> is to write an instance of <see cref="IPerformActionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class PerformActionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IPerformActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPerformActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PerformActionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.performedAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.performedAction, "performedAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs
new file mode 100644
index 000000000..8010e57f5
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs
@@ -0,0 +1,204 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PortConjugationWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="PortConjugationWriter" /> is to write an instance of <see cref="IPortConjugation" />
+    /// to the XMI document
+    /// </summary>
+    public static class PortConjugationWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IPortConjugation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPortConjugation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IPortConjugation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PortConjugation");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.ConjugatedType != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+            }
+            if (poco.OriginalPortDefinition != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OriginalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.conjugatedPortDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs
new file mode 100644
index 000000000..483078500
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs
@@ -0,0 +1,625 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PortDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="PortDefinitionWriter" /> is to write an instance of <see cref="IPortDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class PortDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IPortDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPortDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IPortDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PortDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.conjugatedPortDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs
new file mode 100644
index 000000000..15279d011
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs
@@ -0,0 +1,757 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PortUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="PortUsageWriter" /> is to write an instance of <see cref="IPortUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class PortUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IPortUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPortUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IPortUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PortUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.portDefinition != null)
+                {
+                    foreach (var item in poco.portDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "portDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs
new file mode 100644
index 000000000..7fc20e2d3
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs
@@ -0,0 +1,397 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="PredicateWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="PredicateWriter" /> is to write an instance of <see cref="IPredicate" />
+    /// to the XMI document
+    /// </summary>
+    public static class PredicateWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IPredicate" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPredicate" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IPredicate poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Predicate");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs
new file mode 100644
index 000000000..0788c4562
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs
@@ -0,0 +1,204 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RedefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="RedefinitionWriter" /> is to write an instance of <see cref="IRedefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class RedefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IRedefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRedefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IRedefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Redefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+            if (poco.RedefinedFeature != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.RedefinedFeature, "redefinedFeature", elementOriginMap, currentFileUri);
+            }
+            if (poco.RedefiningFeature != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.RedefiningFeature, "redefiningFeature", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs
new file mode 100644
index 000000000..cf6073f51
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs
@@ -0,0 +1,200 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ReferenceSubsettingWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ReferenceSubsettingWriter" /> is to write an instance of <see cref="IReferenceSubsetting" />
+    /// to the XMI document
+    /// </summary>
+    public static class ReferenceSubsettingWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IReferenceSubsetting" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IReferenceSubsetting" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ReferenceSubsetting");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+            if (poco.ReferencedFeature != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ReferencedFeature, "referencedFeature", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.referencingFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencingFeature, "referencingFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs
new file mode 100644
index 000000000..28545e9e6
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs
@@ -0,0 +1,746 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ReferenceUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ReferenceUsageWriter" /> is to write an instance of <see cref="IReferenceUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class ReferenceUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IReferenceUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IReferenceUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IReferenceUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ReferenceUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.definition != null)
+                {
+                    foreach (var item in poco.definition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs
new file mode 100644
index 000000000..15ac6a785
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs
@@ -0,0 +1,627 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RenderingDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="RenderingDefinitionWriter" /> is to write an instance of <see cref="IRenderingDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class RenderingDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IRenderingDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRenderingDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IRenderingDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RenderingDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.rendering != null)
+                {
+                    foreach (var item in poco.rendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "rendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs
new file mode 100644
index 000000000..75c63dad2
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs
@@ -0,0 +1,769 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RenderingUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="RenderingUsageWriter" /> is to write an instance of <see cref="IRenderingUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class RenderingUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IRenderingUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRenderingUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IRenderingUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RenderingUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.renderingDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.renderingDefinition, "renderingDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs
new file mode 100644
index 000000000..3539e4970
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs
@@ -0,0 +1,222 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RequirementConstraintMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="RequirementConstraintMembershipWriter" /> is to write an instance of <see cref="IRequirementConstraintMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class RequirementConstraintMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IRequirementConstraintMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRequirementConstraintMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IRequirementConstraintMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementConstraintMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConstraint, "ownedConstraint", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.referencedConstraint != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedConstraint, "referencedConstraint", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs
new file mode 100644
index 000000000..1cd9cbb28
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs
@@ -0,0 +1,687 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RequirementDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="RequirementDefinitionWriter" /> is to write an instance of <see cref="IRequirementDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class RequirementDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IRequirementDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRequirementDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IRequirementDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs
new file mode 100644
index 000000000..b7bb5b09b
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs
@@ -0,0 +1,814 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RequirementUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="RequirementUsageWriter" /> is to write an instance of <see cref="IRequirementUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class RequirementUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IRequirementUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRequirementUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IRequirementUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.requirementDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs
new file mode 100644
index 000000000..3f0636cc8
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs
@@ -0,0 +1,223 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="RequirementVerificationMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="RequirementVerificationMembershipWriter" /> is to write an instance of <see cref="IRequirementVerificationMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class RequirementVerificationMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IRequirementVerificationMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRequirementVerificationMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IRequirementVerificationMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementVerificationMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedRequirement, "ownedRequirement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.verifiedRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.verifiedRequirement, "verifiedRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs
new file mode 100644
index 000000000..fcef3ec9e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs
@@ -0,0 +1,215 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ResultExpressionMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ResultExpressionMembershipWriter" /> is to write an instance of <see cref="IResultExpressionMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class ResultExpressionMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IResultExpressionMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IResultExpressionMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IResultExpressionMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ResultExpressionMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedResultExpression != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedResultExpression, "ownedResultExpression", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs
new file mode 100644
index 000000000..42e73adda
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs
@@ -0,0 +1,216 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ReturnParameterMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ReturnParameterMembershipWriter" /> is to write an instance of <see cref="IReturnParameterMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class ReturnParameterMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IReturnParameterMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IReturnParameterMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IReturnParameterMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ReturnParameterMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMemberParameter != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs
new file mode 100644
index 000000000..ad3f4abe7
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs
@@ -0,0 +1,826 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SatisfyRequirementUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SatisfyRequirementUsageWriter" /> is to write an instance of <see cref="ISatisfyRequirementUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class SatisfyRequirementUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISatisfyRequirementUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISatisfyRequirementUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SatisfyRequirementUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsNegated)
+            {
+                xmlWriter.WriteAttributeString("isNegated", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.requirementDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.satisfiedRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.satisfiedRequirement, "satisfiedRequirement", elementOriginMap, currentFileUri);
+                }
+                if (poco.satisfyingFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.satisfyingFeature, "satisfyingFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs
new file mode 100644
index 000000000..a387ee3f0
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs
@@ -0,0 +1,520 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SelectExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SelectExpressionWriter" /> is to write an instance of <see cref="ISelectExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class SelectExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISelectExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISelectExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISelectExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SelectExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                xmlWriter.WriteAttributeString("operator", poco.Operator);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.instantiatedType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs
new file mode 100644
index 000000000..48afdd852
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs
@@ -0,0 +1,778 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SendActionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SendActionUsageWriter" /> is to write an instance of <see cref="ISendActionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class SendActionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISendActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISendActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISendActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SendActionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.payloadArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                }
+                if (poco.receiverArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                }
+                if (poco.senderArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.senderArgument, "senderArgument", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs
new file mode 100644
index 000000000..6bc394304
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs
@@ -0,0 +1,203 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SpecializationWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SpecializationWriter" /> is to write an instance of <see cref="ISpecialization" />
+    /// to the XMI document
+    /// </summary>
+    public static class SpecializationWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISpecialization" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISpecialization" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISpecialization poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Specialization");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.General != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.General, "general", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+            if (poco.Specific != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Specific, "specific", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs
new file mode 100644
index 000000000..fde2a7bc7
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs
@@ -0,0 +1,217 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StakeholderMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="StakeholderMembershipWriter" /> is to write an instance of <see cref="IStakeholderMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class StakeholderMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IStakeholderMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStakeholderMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IStakeholderMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StakeholderMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedStakeholderParameter != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedStakeholderParameter, "ownedStakeholderParameter", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs
new file mode 100644
index 000000000..aa99a726a
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs
@@ -0,0 +1,658 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StateDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="StateDefinitionWriter" /> is to write an instance of <see cref="IStateDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class StateDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IStateDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStateDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IStateDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StateDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsParallel)
+            {
+                xmlWriter.WriteAttributeString("isParallel", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.doAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.entryAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.exitAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.state != null)
+                {
+                    foreach (var item in poco.state)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "state", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs
new file mode 100644
index 000000000..4e5f5dc4e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs
@@ -0,0 +1,218 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StateSubactionMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.States;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="StateSubactionMembershipWriter" /> is to write an instance of <see cref="IStateSubactionMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class StateSubactionMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IStateSubactionMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStateSubactionMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IStateSubactionMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StateSubactionMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.action, "action", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs
new file mode 100644
index 000000000..9700ad2dd
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs
@@ -0,0 +1,781 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StateUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="StateUsageWriter" /> is to write an instance of <see cref="IStateUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class StateUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IStateUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStateUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IStateUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StateUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsParallel)
+            {
+                xmlWriter.WriteAttributeString("isParallel", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.doAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.entryAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.exitAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.stateDefinition != null)
+                {
+                    foreach (var item in poco.stateDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stateDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs
new file mode 100644
index 000000000..d5084ad58
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs
@@ -0,0 +1,498 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StepWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="StepWriter" /> is to write an instance of <see cref="IStep" />
+    /// to the XMI document
+    /// </summary>
+    public static class StepWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IStep" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStep" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IStep poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Step");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.behavior != null)
+                {
+                    foreach (var item in poco.behavior)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "behavior", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs
new file mode 100644
index 000000000..4f99f5250
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs
@@ -0,0 +1,375 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="StructureWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="StructureWriter" /> is to write an instance of <see cref="IStructure" />
+    /// to the XMI document
+    /// </summary>
+    public static class StructureWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IStructure" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStructure" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IStructure poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Structure");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs
new file mode 100644
index 000000000..80c521f69
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs
@@ -0,0 +1,204 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SubclassificationWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SubclassificationWriter" /> is to write an instance of <see cref="ISubclassification" />
+    /// to the XMI document
+    /// </summary>
+    public static class SubclassificationWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISubclassification" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISubclassification" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISubclassification poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Subclassification");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+            if (poco.Subclassifier != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Subclassifier, "subclassifier", elementOriginMap, currentFileUri);
+            }
+            if (poco.Superclassifier != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Superclassifier, "superclassifier", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningClassifier != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningClassifier, "owningClassifier", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs
new file mode 100644
index 000000000..9d922b663
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs
@@ -0,0 +1,217 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SubjectMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SubjectMembershipWriter" /> is to write an instance of <see cref="ISubjectMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class SubjectMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISubjectMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISubjectMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISubjectMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SubjectMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubjectParameter != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedSubjectParameter, "ownedSubjectParameter", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs
new file mode 100644
index 000000000..f7747a64a
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs
@@ -0,0 +1,204 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SubsettingWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SubsettingWriter" /> is to write an instance of <see cref="ISubsetting" />
+    /// to the XMI document
+    /// </summary>
+    public static class SubsettingWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISubsetting" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISubsetting" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISubsetting poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Subsetting");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+            if (poco.SubsettedFeature != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.SubsettedFeature, "subsettedFeature", elementOriginMap, currentFileUri);
+            }
+            if (poco.SubsettingFeature != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.SubsettingFeature, "subsettingFeature", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs
new file mode 100644
index 000000000..d3b5cdafd
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs
@@ -0,0 +1,792 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SuccessionAsUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SuccessionAsUsageWriter" /> is to write an instance of <see cref="ISuccessionAsUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class SuccessionAsUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISuccessionAsUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISuccessionAsUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SuccessionAsUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.association != null)
+                {
+                    foreach (var item in poco.association)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.definition != null)
+                {
+                    foreach (var item in poco.definition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs
new file mode 100644
index 000000000..c0b2027ef
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs
@@ -0,0 +1,838 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SuccessionFlowUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SuccessionFlowUsageWriter" /> is to write an instance of <see cref="ISuccessionFlowUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class SuccessionFlowUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISuccessionFlowUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISuccessionFlowUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SuccessionFlowUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.flowDefinition != null)
+                {
+                    foreach (var item in poco.flowDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.flowEnd != null)
+                {
+                    foreach (var item in poco.flowEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.payloadFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.payloadType != null)
+                {
+                    foreach (var item in poco.payloadType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.sourceOutputFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.targetInputFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs
new file mode 100644
index 000000000..5f45a0ddd
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs
@@ -0,0 +1,558 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SuccessionFlowWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SuccessionFlowWriter" /> is to write an instance of <see cref="ISuccessionFlow" />
+    /// to the XMI document
+    /// </summary>
+    public static class SuccessionFlowWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISuccessionFlow" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISuccessionFlow" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SuccessionFlow");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.flowEnd != null)
+                {
+                    foreach (var item in poco.flowEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.interaction != null)
+                {
+                    foreach (var item in poco.interaction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interaction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.payloadFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.payloadType != null)
+                {
+                    foreach (var item in poco.payloadType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.sourceOutputFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.targetInputFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs
new file mode 100644
index 000000000..f27b9b098
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs
@@ -0,0 +1,529 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="SuccessionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="SuccessionWriter" /> is to write an instance of <see cref="ISuccession" />
+    /// to the XMI document
+    /// </summary>
+    public static class SuccessionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ISuccession" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISuccession" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ISuccession poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Succession");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.association != null)
+                {
+                    foreach (var item in poco.association)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.defaultFeaturingType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.sourceFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs
new file mode 100644
index 000000000..eb04b58cc
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs
@@ -0,0 +1,770 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TerminateActionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="TerminateActionUsageWriter" /> is to write an instance of <see cref="ITerminateActionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class TerminateActionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ITerminateActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITerminateActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TerminateActionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.terminatedOccurrenceArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.terminatedOccurrenceArgument, "terminatedOccurrenceArgument", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs
new file mode 100644
index 000000000..517b08398
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs
@@ -0,0 +1,198 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TextualRepresentationWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="TextualRepresentationWriter" /> is to write an instance of <see cref="ITextualRepresentation" />
+    /// to the XMI document
+    /// </summary>
+    public static class TextualRepresentationWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ITextualRepresentation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITextualRepresentation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ITextualRepresentation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TextualRepresentation");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Body))
+            {
+                xmlWriter.WriteAttributeString("body", poco.Body);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.Language))
+            {
+                xmlWriter.WriteAttributeString("language", poco.Language);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.representedElement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.representedElement, "representedElement", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs
new file mode 100644
index 000000000..962a2dd55
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs
@@ -0,0 +1,218 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TransitionFeatureMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.Systems.States;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="TransitionFeatureMembershipWriter" /> is to write an instance of <see cref="ITransitionFeatureMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class TransitionFeatureMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ITransitionFeatureMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITransitionFeatureMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TransitionFeatureMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.transitionFeature != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.transitionFeature, "transitionFeature", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs
new file mode 100644
index 000000000..c53a659e6
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs
@@ -0,0 +1,800 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TransitionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="TransitionUsageWriter" /> is to write an instance of <see cref="ITransitionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class TransitionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ITransitionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITransitionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ITransitionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TransitionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.effectAction != null)
+                {
+                    foreach (var item in poco.effectAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "effectAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.guardExpression != null)
+                {
+                    foreach (var item in poco.guardExpression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "guardExpression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.source != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.source, "source", elementOriginMap, currentFileUri);
+                }
+                if (poco.succession != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.succession, "succession", elementOriginMap, currentFileUri);
+                }
+                if (poco.target != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.target, "target", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.triggerAction != null)
+                {
+                    foreach (var item in poco.triggerAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "triggerAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs
new file mode 100644
index 000000000..58ceda4b9
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs
@@ -0,0 +1,519 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TriggerInvocationExpressionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Actions;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="TriggerInvocationExpressionWriter" /> is to write an instance of <see cref="ITriggerInvocationExpression" />
+    /// to the XMI document
+    /// </summary>
+    public static class TriggerInvocationExpressionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ITriggerInvocationExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITriggerInvocationExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TriggerInvocationExpression");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariable)
+            {
+                xmlWriter.WriteAttributeString("isVariable", "true");
+            }
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.function != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.instantiatedType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs
new file mode 100644
index 000000000..d707ac01f
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs
@@ -0,0 +1,204 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TypeFeaturingWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="TypeFeaturingWriter" /> is to write an instance of <see cref="ITypeFeaturing" />
+    /// to the XMI document
+    /// </summary>
+    public static class TypeFeaturingWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="ITypeFeaturing" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITypeFeaturing" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TypeFeaturing");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.FeatureOfType != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeatureOfType, "featureOfType", elementOriginMap, currentFileUri);
+            }
+            if (poco.FeaturingType != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeaturingType, "featuringType", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureOfType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureOfType, "owningFeatureOfType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs
new file mode 100644
index 000000000..e884fcd13
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs
@@ -0,0 +1,365 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="TypeWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="TypeWriter" /> is to write an instance of <see cref="IType" />
+    /// to the XMI document
+    /// </summary>
+    public static class TypeWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IType" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IType" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IType poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Type");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs
new file mode 100644
index 000000000..1fb4b40fe
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs
@@ -0,0 +1,199 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UnioningWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="UnioningWriter" /> is to write an instance of <see cref="IUnioning" />
+    /// to the XMI document
+    /// </summary>
+    public static class UnioningWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IUnioning" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IUnioning" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IUnioning poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Unioning");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+            if (poco.UnioningType != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.UnioningType, "unioningType", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.typeUnioned != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeUnioned, "typeUnioned", elementOriginMap, currentFileUri);
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs
new file mode 100644
index 000000000..826bd7b66
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs
@@ -0,0 +1,746 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="UsageWriter" /> is to write an instance of <see cref="IUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class UsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Usage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.definition != null)
+                {
+                    foreach (var item in poco.definition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs
new file mode 100644
index 000000000..f4a016b80
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs
@@ -0,0 +1,680 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UseCaseDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="UseCaseDefinitionWriter" /> is to write an instance of <see cref="IUseCaseDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class UseCaseDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IUseCaseDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IUseCaseDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:UseCaseDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.calculation != null)
+                {
+                    foreach (var item in poco.calculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.includedUseCase != null)
+                {
+                    foreach (var item in poco.includedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.objectiveRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs
new file mode 100644
index 000000000..887af6ba4
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs
@@ -0,0 +1,800 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="UseCaseUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="UseCaseUsageWriter" /> is to write an instance of <see cref="IUseCaseUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class UseCaseUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IUseCaseUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IUseCaseUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:UseCaseUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.includedUseCase != null)
+                {
+                    foreach (var item in poco.includedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.objectiveRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.useCaseDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs
new file mode 100644
index 000000000..988fa9bbb
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs
@@ -0,0 +1,213 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="VariantMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="VariantMembershipWriter" /> is to write an instance of <see cref="IVariantMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class VariantMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IVariantMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IVariantMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IVariantMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:VariantMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membershipOwningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVariantUsage != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedVariantUsage, "ownedVariantUsage", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs
new file mode 100644
index 000000000..3bc489db6
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs
@@ -0,0 +1,680 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="VerificationCaseDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="VerificationCaseDefinitionWriter" /> is to write an instance of <see cref="IVerificationCaseDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class VerificationCaseDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IVerificationCaseDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IVerificationCaseDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:VerificationCaseDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.calculation != null)
+                {
+                    foreach (var item in poco.calculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.objectiveRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.verifiedRequirement != null)
+                {
+                    foreach (var item in poco.verifiedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "verifiedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs
new file mode 100644
index 000000000..263c2d472
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs
@@ -0,0 +1,804 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="VerificationCaseUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="VerificationCaseUsageWriter" /> is to write an instance of <see cref="IVerificationCaseUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class VerificationCaseUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IVerificationCaseUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IVerificationCaseUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:VerificationCaseUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.caseDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.objectiveRequirement != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.verificationCaseDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.verificationCaseDefinition, "verificationCaseDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.verifiedRequirement != null)
+                {
+                    foreach (var item in poco.verifiedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "verifiedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs
new file mode 100644
index 000000000..ccbd533a9
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs
@@ -0,0 +1,646 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ViewDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ViewDefinitionWriter" /> is to write an instance of <see cref="IViewDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class ViewDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IViewDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IViewDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IViewDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.satisfiedViewpoint != null)
+                {
+                    foreach (var item in poco.satisfiedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.view != null)
+                {
+                    foreach (var item in poco.view)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "view", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.viewCondition != null)
+                {
+                    foreach (var item in poco.viewCondition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewCondition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.viewRendering != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs
new file mode 100644
index 000000000..461b45e79
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs
@@ -0,0 +1,219 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ViewRenderingMembershipWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ViewRenderingMembershipWriter" /> is to write an instance of <see cref="IViewRenderingMembership" />
+    /// to the XMI document
+    /// </summary>
+    public static class ViewRenderingMembershipWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IViewRenderingMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IViewRenderingMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewRenderingMembership");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsImplied)
+            {
+                xmlWriter.WriteAttributeString("isImplied", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelatedElement != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedRendering, "ownedRendering", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.referencedRendering != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedRendering, "referencedRendering", elementOriginMap, currentFileUri);
+                }
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs
new file mode 100644
index 000000000..c345f2ddf
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs
@@ -0,0 +1,795 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ViewUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ViewUsageWriter" /> is to write an instance of <see cref="IViewUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class ViewUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IViewUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IViewUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IViewUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.exposedElement != null)
+                {
+                    foreach (var item in poco.exposedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "exposedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.satisfiedViewpoint != null)
+                {
+                    foreach (var item in poco.satisfiedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.viewCondition != null)
+                {
+                    foreach (var item in poco.viewCondition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewCondition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.viewDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewDefinition, "viewDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.viewRendering != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs
new file mode 100644
index 000000000..314cfb490
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs
@@ -0,0 +1,694 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ViewpointDefinitionWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ViewpointDefinitionWriter" /> is to write an instance of <see cref="IViewpointDefinition" />
+    /// to the XMI document
+    /// </summary>
+    public static class ViewpointDefinitionWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IViewpointDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IViewpointDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IViewpointDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewpointDefinition");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.viewpointStakeholder != null)
+                {
+                    foreach (var item in poco.viewpointStakeholder)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewpointStakeholder", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs
new file mode 100644
index 000000000..97971694a
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs
@@ -0,0 +1,821 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="ViewpointUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="ViewpointUsageWriter" /> is to write an instance of <see cref="IViewpointUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class ViewpointUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IViewpointUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IViewpointUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IViewpointUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewpointUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.result != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.subjectParameter != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.viewpointDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewpointDefinition, "viewpointDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.viewpointStakeholder != null)
+                {
+                    foreach (var item in poco.viewpointStakeholder)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewpointStakeholder", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs
new file mode 100644
index 000000000..d01cf68a6
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs
@@ -0,0 +1,778 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="WhileLoopActionUsageWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.Core.Types;
+    using SysML2.NET.Core.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="WhileLoopActionUsageWriter" /> is to write an instance of <see cref="IWhileLoopActionUsage" />
+    /// to the XMI document
+    /// </summary>
+    public static class WhileLoopActionUsageWriter
+    {
+        /// <summary>
+        /// Writes the <see cref="IWhileLoopActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IWhileLoopActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public static void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:WhileLoopActionUsage");
+            xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
+            }
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
+            }
+            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                xmlWriter.WriteAttributeString("elementId", poco.ElementId);
+            }
+            if (poco.IsAbstract)
+            {
+                xmlWriter.WriteAttributeString("isAbstract", "true");
+            }
+            if (poco.IsComposite)
+            {
+                xmlWriter.WriteAttributeString("isComposite", "true");
+            }
+            if (poco.IsConstant)
+            {
+                xmlWriter.WriteAttributeString("isConstant", "true");
+            }
+            if (poco.IsDerived)
+            {
+                xmlWriter.WriteAttributeString("isDerived", "true");
+            }
+            if (poco.IsEnd)
+            {
+                xmlWriter.WriteAttributeString("isEnd", "true");
+            }
+            if (poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+            if (poco.IsIndividual)
+            {
+                xmlWriter.WriteAttributeString("isIndividual", "true");
+            }
+            if (poco.IsOrdered)
+            {
+                xmlWriter.WriteAttributeString("isOrdered", "true");
+            }
+            if (poco.IsPortion)
+            {
+                xmlWriter.WriteAttributeString("isPortion", "true");
+            }
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+            if (poco.IsUnique)
+            {
+                xmlWriter.WriteAttributeString("isUnique", "true");
+            }
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            // Derived scalar properties
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+                if (poco.mayTimeVary)
+                {
+                    xmlWriter.WriteAttributeString("mayTimeVary", "true");
+                }
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    xmlWriter.WriteAttributeString("name", poco.name);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
+                }
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
+                }
+            }
+
+            // Reference/containment properties as child elements
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+            }
+            if (poco.OwningRelationship != null)
+            {
+                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.bodyAction != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                }
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.crossFeature != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.endOwningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.featureTarget != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.individualDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.multiplicity != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedConjugator != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                }
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.owner != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningDefinition != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningFeatureMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningMembership != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningNamespace != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningType != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+                if (poco.owningUsage != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.untilArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.untilArgument, "untilArgument", elementOriginMap, currentFileUri);
+                }
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    }
+                }
+                if (poco.whileArgument != null)
+                {
+                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.whileArgument, "whileArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
new file mode 100644
index 000000000..ee768865d
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
@@ -0,0 +1,480 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="XmiDataWriterFacade.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+    using SysML2.NET.Core.POCO.Root.Elements;
+
+    /// <summary>
+    /// The purpose of the <see cref="XmiDataWriterFacade"/> is to dispatch writing of <see cref="IData"/> instances
+    /// to the appropriate per-type static writer class
+    /// </summary>
+    public class XmiDataWriterFacade : IXmiDataWriterFacade
+    {
+        /// <summary>
+        /// A dictionary that contains actions that write <see cref="IData"/> based on a key that represents the POCO type name
+        /// </summary>
+        private readonly Dictionary<string, Action<XmlWriter, IData, string, bool, IXmiDataWriterFacade, IXmiElementOriginMap, Uri>> writerCache;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="XmiDataWriterFacade"/>
+        /// </summary>
+        public XmiDataWriterFacade()
+        {
+            this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, bool, IXmiDataWriterFacade, IXmiElementOriginMap, Uri>>
+            {
+                ["AcceptActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AcceptActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["ActionDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ActionDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["ActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["ActorMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ActorMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["AllocationDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AllocationDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["AllocationUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AllocationUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["AnalysisCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AnalysisCaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["AnalysisCaseUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AnalysisCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["AnnotatingElement"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AnnotatingElementWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, includeDerived, facade, originMap, uri),
+                ["Annotation"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AnnotationWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, includeDerived, facade, originMap, uri),
+                ["AssertConstraintUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AssertConstraintUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["AssignmentActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AssignmentActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["Association"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AssociationWriter.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, includeDerived, facade, originMap, uri),
+                ["AssociationStructure"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AssociationStructureWriter.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, includeDerived, facade, originMap, uri),
+                ["AttributeDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AttributeDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["AttributeUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    AttributeUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["Behavior"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    BehaviorWriter.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, includeDerived, facade, originMap, uri),
+                ["BindingConnector"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    BindingConnectorWriter.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, includeDerived, facade, originMap, uri),
+                ["BindingConnectorAsUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    BindingConnectorAsUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["BooleanExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    BooleanExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["CalculationDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    CalculationDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["CalculationUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    CalculationUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["CaseDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    CaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["CaseUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    CaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["Class"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ClassWriter.Write(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, includeDerived, facade, originMap, uri),
+                ["Classifier"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ClassifierWriter.Write(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, includeDerived, facade, originMap, uri),
+                ["CollectExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    CollectExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["Comment"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    CommentWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, includeDerived, facade, originMap, uri),
+                ["ConcernDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConcernDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["ConcernUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConcernUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["ConjugatedPortDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConjugatedPortDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["ConjugatedPortTyping"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConjugatedPortTypingWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, includeDerived, facade, originMap, uri),
+                ["Conjugation"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConjugationWriter.Write(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, includeDerived, facade, originMap, uri),
+                ["ConnectionDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConnectionDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["ConnectionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConnectionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["Connector"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConnectorWriter.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, includeDerived, facade, originMap, uri),
+                ["ConstraintDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConstraintDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["ConstraintUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConstraintUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["ConstructorExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ConstructorExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["CrossSubsetting"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    CrossSubsettingWriter.Write(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, includeDerived, facade, originMap, uri),
+                ["DataType"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    DataTypeWriter.Write(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, includeDerived, facade, originMap, uri),
+                ["DecisionNode"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    DecisionNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, includeDerived, facade, originMap, uri),
+                ["Definition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    DefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["Dependency"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    DependencyWriter.Write(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, includeDerived, facade, originMap, uri),
+                ["Differencing"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    DifferencingWriter.Write(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, includeDerived, facade, originMap, uri),
+                ["Disjoining"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    DisjoiningWriter.Write(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, includeDerived, facade, originMap, uri),
+                ["Documentation"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    DocumentationWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, includeDerived, facade, originMap, uri),
+                ["ElementFilterMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ElementFilterMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["EndFeatureMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    EndFeatureMembershipWriter.Write(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["EnumerationDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    EnumerationDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["EnumerationUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    EnumerationUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["EventOccurrenceUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    EventOccurrenceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["ExhibitStateUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ExhibitStateUsageWriter.Write(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["Expression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["Feature"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FeatureWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, includeDerived, facade, originMap, uri),
+                ["FeatureChainExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FeatureChainExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["FeatureChaining"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FeatureChainingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, includeDerived, facade, originMap, uri),
+                ["FeatureInverting"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FeatureInvertingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, includeDerived, facade, originMap, uri),
+                ["FeatureMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FeatureMembershipWriter.Write(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["FeatureReferenceExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FeatureReferenceExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["FeatureTyping"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FeatureTypingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, includeDerived, facade, originMap, uri),
+                ["FeatureValue"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FeatureValueWriter.Write(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, includeDerived, facade, originMap, uri),
+                ["Flow"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FlowWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, includeDerived, facade, originMap, uri),
+                ["FlowDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FlowDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["FlowEnd"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FlowEndWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, includeDerived, facade, originMap, uri),
+                ["FlowUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FlowUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["ForkNode"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ForkNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, includeDerived, facade, originMap, uri),
+                ["ForLoopActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ForLoopActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["FramedConcernMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FramedConcernMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["Function"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    FunctionWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, includeDerived, facade, originMap, uri),
+                ["IfActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    IfActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["IncludeUseCaseUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    IncludeUseCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["IndexExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    IndexExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["Interaction"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    InteractionWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, includeDerived, facade, originMap, uri),
+                ["InterfaceDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    InterfaceDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["InterfaceUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    InterfaceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["Intersecting"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    IntersectingWriter.Write(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, includeDerived, facade, originMap, uri),
+                ["Invariant"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    InvariantWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, includeDerived, facade, originMap, uri),
+                ["InvocationExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    InvocationExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["ItemDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ItemDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["ItemUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ItemUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["JoinNode"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    JoinNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, includeDerived, facade, originMap, uri),
+                ["LibraryPackage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    LibraryPackageWriter.Write(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, includeDerived, facade, originMap, uri),
+                ["LiteralBoolean"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    LiteralBooleanWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, includeDerived, facade, originMap, uri),
+                ["LiteralExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    LiteralExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["LiteralInfinity"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    LiteralInfinityWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, includeDerived, facade, originMap, uri),
+                ["LiteralInteger"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    LiteralIntegerWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, includeDerived, facade, originMap, uri),
+                ["LiteralRational"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    LiteralRationalWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, includeDerived, facade, originMap, uri),
+                ["LiteralString"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    LiteralStringWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, includeDerived, facade, originMap, uri),
+                ["Membership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MembershipWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["MembershipExpose"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MembershipExposeWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, includeDerived, facade, originMap, uri),
+                ["MembershipImport"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MembershipImportWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, includeDerived, facade, originMap, uri),
+                ["MergeNode"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MergeNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, includeDerived, facade, originMap, uri),
+                ["Metaclass"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MetaclassWriter.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, includeDerived, facade, originMap, uri),
+                ["MetadataAccessExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MetadataAccessExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["MetadataDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MetadataDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["MetadataFeature"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MetadataFeatureWriter.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, includeDerived, facade, originMap, uri),
+                ["MetadataUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MetadataUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["Multiplicity"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MultiplicityWriter.Write(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, includeDerived, facade, originMap, uri),
+                ["MultiplicityRange"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    MultiplicityRangeWriter.Write(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, includeDerived, facade, originMap, uri),
+                ["Namespace"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    NamespaceWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, includeDerived, facade, originMap, uri),
+                ["NamespaceExpose"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    NamespaceExposeWriter.Write(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, includeDerived, facade, originMap, uri),
+                ["NamespaceImport"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    NamespaceImportWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, includeDerived, facade, originMap, uri),
+                ["NullExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    NullExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["ObjectiveMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ObjectiveMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["OccurrenceDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    OccurrenceDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["OccurrenceUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    OccurrenceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["OperatorExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    OperatorExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["OwningMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    OwningMembershipWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["Package"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    PackageWriter.Write(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, includeDerived, facade, originMap, uri),
+                ["ParameterMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ParameterMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["PartDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    PartDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["PartUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    PartUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["PayloadFeature"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    PayloadFeatureWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, includeDerived, facade, originMap, uri),
+                ["PerformActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    PerformActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["PortConjugation"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    PortConjugationWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, includeDerived, facade, originMap, uri),
+                ["PortDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    PortDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["PortUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    PortUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["Predicate"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    PredicateWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, includeDerived, facade, originMap, uri),
+                ["Redefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    RedefinitionWriter.Write(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["ReferenceSubsetting"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ReferenceSubsettingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, includeDerived, facade, originMap, uri),
+                ["ReferenceUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ReferenceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["RenderingDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    RenderingDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["RenderingUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    RenderingUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["RequirementConstraintMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    RequirementConstraintMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["RequirementDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    RequirementDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["RequirementUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    RequirementUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["RequirementVerificationMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    RequirementVerificationMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["ResultExpressionMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ResultExpressionMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["ReturnParameterMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ReturnParameterMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["SatisfyRequirementUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SatisfyRequirementUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["SelectExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SelectExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["SendActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SendActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["Specialization"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SpecializationWriter.Write(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, includeDerived, facade, originMap, uri),
+                ["StakeholderMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    StakeholderMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["StateDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    StateDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["StateSubactionMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    StateSubactionMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["StateUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    StateUsageWriter.Write(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["Step"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    StepWriter.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, includeDerived, facade, originMap, uri),
+                ["Structure"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    StructureWriter.Write(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, includeDerived, facade, originMap, uri),
+                ["Subclassification"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SubclassificationWriter.Write(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, includeDerived, facade, originMap, uri),
+                ["SubjectMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SubjectMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["Subsetting"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SubsettingWriter.Write(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, includeDerived, facade, originMap, uri),
+                ["Succession"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SuccessionWriter.Write(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, includeDerived, facade, originMap, uri),
+                ["SuccessionAsUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SuccessionAsUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["SuccessionFlow"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SuccessionFlowWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, includeDerived, facade, originMap, uri),
+                ["SuccessionFlowUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    SuccessionFlowUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["TerminateActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    TerminateActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["TextualRepresentation"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    TextualRepresentationWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, includeDerived, facade, originMap, uri),
+                ["TransitionFeatureMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    TransitionFeatureMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["TransitionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    TransitionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["TriggerInvocationExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    TriggerInvocationExpressionWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, includeDerived, facade, originMap, uri),
+                ["Type"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    TypeWriter.Write(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, includeDerived, facade, originMap, uri),
+                ["TypeFeaturing"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    TypeFeaturingWriter.Write(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, includeDerived, facade, originMap, uri),
+                ["Unioning"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    UnioningWriter.Write(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, includeDerived, facade, originMap, uri),
+                ["Usage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    UsageWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["UseCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    UseCaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["UseCaseUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    UseCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["VariantMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    VariantMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["VerificationCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    VerificationCaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["VerificationCaseUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    VerificationCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["ViewDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ViewDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["ViewpointDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ViewpointDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, includeDerived, facade, originMap, uri),
+                ["ViewpointUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ViewpointUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["ViewRenderingMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ViewRenderingMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, includeDerived, facade, originMap, uri),
+                ["ViewUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    ViewUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["WhileLoopActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
+                    WhileLoopActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, includeDerived, facade, originMap, uri),
+            };
+        }
+
+        /// <summary>
+        /// Writes the specified <see cref="IData"/> as an XMI element by dispatching to the appropriate per-type writer
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="data">The <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            var typeName = data.GetType().Name;
+
+            if (this.writerCache.TryGetValue(typeName, out var writer))
+            {
+                writer(xmlWriter, data, elementName, includeDerivedProperties, this, elementOriginMap, currentFileUri);
+            }
+            else
+            {
+                throw new InvalidOperationException($"No writer found for type {typeName}");
+            }
+        }
+
+        /// <summary>
+        /// Writes a contained child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (elementOriginMap != null && currentFileUri != null)
+            {
+                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
+
+                if (childSourceFile != null && childSourceFile != currentFileUri)
+                {
+                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    return;
+                }
+            }
+
+            this.Write(xmlWriter, childData, elementName, includeDerivedProperties, elementOriginMap, currentFileUri);
+        }
+
+        /// <summary>
+        /// Writes a reference child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (elementOriginMap != null && currentFileUri != null)
+            {
+                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
+
+                if (childSourceFile != null && childSourceFile != currentFileUri)
+                {
+                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    return;
+                }
+            }
+
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("xmi", "idref", null, childData.Id.ToString());
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Writes an href element for cross-file references
+        /// </summary>
+        private static void WriteHrefElement(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile)
+        {
+            var relativePath = currentFile.MakeRelativeUri(targetFile);
+            var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{childData.Id}";
+
+            xmlWriter.WriteStartElement(elementName);
+            xmlWriter.WriteAttributeString("href", href);
+            xmlWriter.WriteEndElement();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// --------THIS IS AN AUTOMATICALLY GENERATED FILE. ANY MANUAL CHANGES WILL BE OVERWRITTEN!--------
+// ------------------------------------------------------------------------------------------------
diff --git a/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs b/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs
new file mode 100644
index 000000000..3b3f25508
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs
@@ -0,0 +1,66 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="IXmiDataWriterFacade.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Xml;
+
+    using SysML2.NET.Common;
+
+    /// <summary>
+    /// The purpose of the <see cref="IXmiDataWriterFacade"/> is to dispatch writing of <see cref="IData"/> instances
+    /// to the appropriate per-type static writer class
+    /// </summary>
+    public interface IXmiDataWriterFacade
+    {
+        /// <summary>
+        /// Writes the specified <see cref="IData"/> as an XMI element by dispatching to the appropriate per-type writer
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="data">The <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null);
+
+        /// <summary>
+        /// Writes a contained child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+
+        /// <summary>
+        /// Writes a reference child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+    }
+}
diff --git a/SysML2.NET.Serializer.Xmi/Writers/IXmiWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/IXmiWriter.cs
deleted file mode 100644
index 04db8b586..000000000
--- a/SysML2.NET.Serializer.Xmi/Writers/IXmiWriter.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// -------------------------------------------------------------------------------------------------
-// <copyright file="IXmiWriter.cs" company="Starion Group S.A.">
-//
-//   Copyright 2022-2026 Starion Group S.A.
-//
-//   Licensed under the Apache License, Version 2.0 (the "License");
-//   you may not use this file except in compliance with the License.
-//   You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-// </copyright>
-// ------------------------------------------------------------------------------------------------
-
-namespace SysML2.NET.Serializer.Xmi.Writers
-{
-    using System;
-    using System.Xml;
-
-    using SysML2.NET.Common;
-
-    /// <summary>
-    /// The purpose of the <see cref="IXmiWriter"/> is to write <see cref="IData"/> instances
-    /// to an <see cref="XmlWriter"/> in XMI format
-    /// </summary>
-    public interface IXmiWriter
-    {
-        /// <summary>
-        /// Writes the specified <see cref="IData"/> as an XMI element
-        /// </summary>
-        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
-        /// <param name="data">The <see cref="IData"/> to write</param>
-        /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
-        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null);
-    }
-}
diff --git a/SysML2.NET.Serializer.Xmi/Writers/XmiWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/XmiWriter.cs
deleted file mode 100644
index be6da36b5..000000000
--- a/SysML2.NET.Serializer.Xmi/Writers/XmiWriter.cs
+++ /dev/null
@@ -1,375 +0,0 @@
-// -------------------------------------------------------------------------------------------------
-// <copyright file="XmiWriter.cs" company="Starion Group S.A.">
-//
-//   Copyright 2022-2026 Starion Group S.A.
-//
-//   Licensed under the Apache License, Version 2.0 (the "License");
-//   you may not use this file except in compliance with the License.
-//   You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-// </copyright>
-// ------------------------------------------------------------------------------------------------
-
-namespace SysML2.NET.Serializer.Xmi.Writers
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.Linq;
-    using System.Reflection;
-    using System.Xml;
-
-    using Microsoft.Extensions.Logging;
-    using Microsoft.Extensions.Logging.Abstractions;
-
-    using SysML2.NET.Common;
-    using SysML2.NET.Core.POCO.Root.Elements;
-    using SysML2.NET.Core.POCO.Root.Namespaces;
-    using SysML2.NET.Decorators;
-
-    /// <summary>
-    /// The purpose of the <see cref="XmiWriter"/> is to write <see cref="IData"/> instances
-    /// to an <see cref="XmlWriter"/> in XMI format using reflection on the POCO [Property] attributes
-    /// </summary>
-    public class XmiWriter : IXmiWriter
-    {
-        private readonly ILogger<XmiWriter> logger;
-
-        private static readonly Dictionary<Type, List<PropertySerializationInfo>> PropertyCache = new Dictionary<Type, List<PropertySerializationInfo>>();
-        private static readonly object PropertyCacheLock = new object();
-
-        public XmiWriter(ILoggerFactory loggerFactory = null)
-        {
-            this.logger = loggerFactory == null ? NullLogger<XmiWriter>.Instance : loggerFactory.CreateLogger<XmiWriter>();
-        }
-
-        /// <summary>
-        /// Writes the specified <see cref="IData"/> as an XMI element
-        /// </summary>
-        public void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
-        {
-            if (xmlWriter == null)
-            {
-                throw new ArgumentNullException(nameof(xmlWriter));
-            }
-
-            if (data == null)
-            {
-                throw new ArgumentNullException(nameof(data));
-            }
-
-            var typeName = data.GetType().Name;
-
-            xmlWriter.WriteStartElement(elementName);
-            xmlWriter.WriteAttributeString("xsi", "type", null, $"sysml:{typeName}");
-            xmlWriter.WriteAttributeString("xmi", "id", null, data.Id.ToString());
-
-            var properties = GetSerializationProperties(data.GetType());
-
-            // Write scalar (non-reference) properties as XML attributes
-            foreach (var propInfo in properties)
-            {
-                if (propInfo.IsDerived && !includeDerivedProperties)
-                {
-                    continue;
-                }
-
-                if (propInfo.IsReference)
-                {
-                    continue;
-                }
-
-                this.WriteScalarAttribute(xmlWriter, data, propInfo);
-            }
-
-            // Write reference and containment properties as child elements
-            foreach (var propInfo in properties)
-            {
-                if (propInfo.IsDerived && !includeDerivedProperties)
-                {
-                    continue;
-                }
-
-                if (!propInfo.IsReference)
-                {
-                    continue;
-                }
-
-                this.WriteReferenceElements(xmlWriter, data, propInfo, includeDerivedProperties, elementOriginMap, currentFileUri);
-            }
-
-            xmlWriter.WriteEndElement();
-        }
-
-        private void WriteScalarAttribute(XmlWriter xmlWriter, IData data, PropertySerializationInfo propInfo)
-        {
-            object value;
-
-            try
-            {
-                value = propInfo.PropertyInfo.GetValue(data);
-            }
-            catch (TargetInvocationException)
-            {
-                return;
-            }
-
-            if (value == null)
-            {
-                return;
-            }
-
-            if (propInfo.IsEnumerable)
-            {
-                var enumerable = (IEnumerable)value;
-                var values = new List<string>();
-
-                foreach (var item in enumerable)
-                {
-                    if (item != null)
-                    {
-                        values.Add(FormatScalarValue(item));
-                    }
-                }
-
-                if (values.Count > 0)
-                {
-                    xmlWriter.WriteAttributeString(propInfo.XmiName, string.Join(" ", values));
-                }
-            }
-            else
-            {
-                var formatted = FormatScalarValue(value);
-
-                if (formatted != null && !IsDefaultValue(value, propInfo))
-                {
-                    xmlWriter.WriteAttributeString(propInfo.XmiName, formatted);
-                }
-            }
-        }
-
-        private void WriteReferenceElements(XmlWriter xmlWriter, IData data, PropertySerializationInfo propInfo, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
-        {
-            object value;
-
-            try
-            {
-                value = propInfo.PropertyInfo.GetValue(data);
-            }
-            catch (TargetInvocationException)
-            {
-                return;
-            }
-
-            if (value == null)
-            {
-                return;
-            }
-
-            if (propInfo.IsEnumerable)
-            {
-                var enumerable = (IEnumerable)value;
-
-                foreach (var item in enumerable)
-                {
-                    if (item is IData childData)
-                    {
-                        if (propInfo.IsComposite)
-                        {
-                            this.WriteContainedElement(xmlWriter, childData, propInfo.XmiName, includeDerivedProperties, elementOriginMap, currentFileUri);
-                        }
-                        else
-                        {
-                            this.WriteReferenceElement(xmlWriter, childData, propInfo.XmiName, elementOriginMap, currentFileUri);
-                        }
-                    }
-                }
-            }
-            else
-            {
-                if (value is IData childData)
-                {
-                    if (propInfo.IsComposite)
-                    {
-                        this.WriteContainedElement(xmlWriter, childData, propInfo.XmiName, includeDerivedProperties, elementOriginMap, currentFileUri);
-                    }
-                    else
-                    {
-                        this.WriteReferenceElement(xmlWriter, childData, propInfo.XmiName, elementOriginMap, currentFileUri);
-                    }
-                }
-            }
-        }
-
-        private void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
-        {
-            if (elementOriginMap != null && currentFileUri != null)
-            {
-                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
-
-                if (childSourceFile != null && childSourceFile != currentFileUri)
-                {
-                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
-                    return;
-                }
-            }
-
-            this.Write(xmlWriter, childData, elementName, includeDerivedProperties, elementOriginMap, currentFileUri);
-        }
-
-        private void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
-        {
-            if (elementOriginMap != null && currentFileUri != null)
-            {
-                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
-
-                if (childSourceFile != null && childSourceFile != currentFileUri)
-                {
-                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
-                    return;
-                }
-            }
-
-            // Same file reference - write as id reference
-            xmlWriter.WriteStartElement(elementName);
-            xmlWriter.WriteAttributeString("xmi", "idref", null, childData.Id.ToString());
-            xmlWriter.WriteEndElement();
-        }
-
-        private static void WriteHrefElement(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile)
-        {
-            var relativePath = currentFile.MakeRelativeUri(targetFile);
-            var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{childData.Id}";
-
-            xmlWriter.WriteStartElement(elementName);
-            xmlWriter.WriteAttributeString("href", href);
-            xmlWriter.WriteEndElement();
-        }
-
-        private static string FormatScalarValue(object value)
-        {
-            switch (value)
-            {
-                case bool b:
-                    return b ? "true" : "false";
-                case int i:
-                    return i.ToString(CultureInfo.InvariantCulture);
-                case double d:
-                    return d.ToString(CultureInfo.InvariantCulture);
-                case Enum e:
-                    return e.ToString();
-                case string s:
-                    return s;
-                default:
-                    return value.ToString();
-            }
-        }
-
-        private static bool IsDefaultValue(object value, PropertySerializationInfo propInfo)
-        {
-            if (propInfo.DefaultValue == null)
-            {
-                return false;
-            }
-
-            var formatted = FormatScalarValue(value);
-            return string.Equals(formatted, propInfo.DefaultValue, StringComparison.OrdinalIgnoreCase);
-        }
-
-        private static List<PropertySerializationInfo> GetSerializationProperties(Type pocoType)
-        {
-            lock (PropertyCacheLock)
-            {
-                if (PropertyCache.TryGetValue(pocoType, out var cached))
-                {
-                    return cached;
-                }
-
-                var result = new List<PropertySerializationInfo>();
-                var interfaces = pocoType.GetInterfaces();
-
-                var processedNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-
-                foreach (var iface in interfaces)
-                {
-                    foreach (var prop in iface.GetProperties())
-                    {
-                        var attr = prop.GetCustomAttribute<PropertyAttribute>();
-
-                        if (attr == null)
-                        {
-                            continue;
-                        }
-
-                        var xmiName = char.ToLowerInvariant(prop.Name[0]) + prop.Name.Substring(1);
-
-                        if (!processedNames.Add(xmiName))
-                        {
-                            continue;
-                        }
-
-                        var propType = prop.PropertyType;
-                        var isEnumerable = propType != typeof(string) && typeof(IEnumerable).IsAssignableFrom(propType);
-                        var elementType = isEnumerable ? GetElementType(propType) : propType;
-                        var isReference = elementType != null && typeof(IData).IsAssignableFrom(elementType);
-
-                        // Try to get the property from the concrete type to ensure we can read it
-                        var concreteProp = pocoType.GetProperty(prop.Name) ?? prop;
-
-                        result.Add(new PropertySerializationInfo
-                        {
-                            PropertyInfo = concreteProp,
-                            XmiName = xmiName,
-                            IsDerived = attr.IsDerived,
-                            IsComposite = attr.Aggregation == AggregationKind.Composite,
-                            IsReference = isReference,
-                            IsEnumerable = isEnumerable,
-                            DefaultValue = attr.DefaultValue
-                        });
-                    }
-                }
-
-                PropertyCache[pocoType] = result;
-                return result;
-            }
-        }
-
-        private static Type GetElementType(Type enumerableType)
-        {
-            if (enumerableType.IsGenericType)
-            {
-                return enumerableType.GetGenericArguments().FirstOrDefault();
-            }
-
-            foreach (var iface in enumerableType.GetInterfaces())
-            {
-                if (iface.IsGenericType && iface.GetGenericTypeDefinition() == typeof(IEnumerable<>))
-                {
-                    return iface.GetGenericArguments().FirstOrDefault();
-                }
-            }
-
-            return null;
-        }
-
-        private class PropertySerializationInfo
-        {
-            public PropertyInfo PropertyInfo { get; set; }
-            public string XmiName { get; set; }
-            public bool IsDerived { get; set; }
-            public bool IsComposite { get; set; }
-            public bool IsReference { get; set; }
-            public bool IsEnumerable { get; set; }
-            public string DefaultValue { get; set; }
-        }
-    }
-}

From 3c2edd73cdbb26fd905109dd05c30e2b976c196c Mon Sep 17 00:00:00 2001
From: samatstarion <s.gerene@stariongroup.eu>
Date: Sat, 7 Mar 2026 23:58:40 +0100
Subject: [PATCH 5/9] refactor writers

xmireader / writer update with impliedinclude
---
 .../AutoGenReaders/AnnotatingElementReader.cs |   15 +-
 .../Core/AutoGenReaders/AssociationReader.cs  |   23 +-
 .../Core/AutoGenReaders/DependencyReader.cs   |   31 +-
 .../EnumerationDefinitionReader.cs            |   15 +-
 .../UML/Core/AutoGenReaders/FeatureReader.cs  |   15 +-
 .../AutoGenReaders/FeatureTypingReader.cs     |   31 +-
 .../UML/Core/AutoGenReaders/FlowReader.cs     |   23 +-
 .../FramedConcernMembershipReader.cs          |   23 +-
 .../AutoGenReaders/LiteralIntegerReader.cs    |   15 +-
 .../AutoGenReaders/LiteralRationalReader.cs   |   15 +-
 .../Core/AutoGenReaders/MembershipReader.cs   |   27 +-
 .../AutoGenReaders/MultiplicityRangeReader.cs |   15 +-
 .../AutoGenReaders/OwningMembershipReader.cs  |   23 +-
 .../ReferenceSubsettingReader.cs              |   27 +-
 .../AutoGenReaders/RequirementUsageReader.cs  |   15 +-
 .../AutoGenReaders/SelectExpressionReader.cs  |   15 +-
 .../AutoGenReaders/SubclassificationReader.cs |   31 +-
 .../TextualRepresentationReader.cs            |   15 +-
 .../UML/Core/AutoGenReaders/UsageReader.cs    |   15 +-
 .../UmlCoreXmiWriterGenerator.cs              |    2 +
 .../HandleBarHelpers/ClassHelper.cs           |   10 +
 .../HandleBarHelpers/PropertyHelper.cs        |   10 +
 .../SysML2.NET.CodeGenerator.csproj           |    6 +
 ...r-partial-for-attribute-async-template.hbs |   36 +
 ...-writer-partial-for-attribute-template.hbs |    7 +
 ...ter-partial-for-element-async-template.hbs |   22 +
 ...mi-writer-partial-for-element-template.hbs |    8 +-
 .../Uml/core-xmi-writer-facade-template.hbs   |  147 +-
 .../Uml/core-xmi-writer-template.hbs          |  173 +-
 .../RoundTripTestFixture.cs                   |    2 +-
 .../SerializerTestFixture.cs                  |   59 +-
 SysML2.NET.Serializer.Xmi/ISerializer.cs      |   31 +-
 SysML2.NET.Serializer.Xmi/Serializer.cs       |   69 +-
 .../AutoGenWriters/AcceptActionUsageWriter.cs | 1760 +++++++++++++-
 .../AutoGenWriters/ActionDefinitionWriter.cs  | 1377 ++++++++++-
 .../AutoGenWriters/ActionUsageWriter.cs       | 1718 ++++++++++++-
 .../AutoGenWriters/ActorMembershipWriter.cs   |  383 ++-
 .../AllocationDefinitionWriter.cs             | 1453 ++++++++++-
 .../AutoGenWriters/AllocationUsageWriter.cs   | 1853 ++++++++++++--
 .../AnalysisCaseDefinitionWriter.cs           | 1502 +++++++++++-
 .../AutoGenWriters/AnalysisCaseUsageWriter.cs | 1825 +++++++++++++-
 .../AutoGenWriters/AnnotatingElementWriter.cs |  337 ++-
 .../AutoGenWriters/AnnotationWriter.cs        |  378 ++-
 .../AssertConstraintUsageWriter.cs            | 1761 +++++++++++++-
 .../AssignmentActionUsageWriter.cs            | 1760 +++++++++++++-
 .../AssociationStructureWriter.cs             |  889 ++++++-
 .../AutoGenWriters/AssociationWriter.cs       |  889 ++++++-
 .../AttributeDefinitionWriter.cs              | 1331 +++++++++-
 .../AutoGenWriters/AttributeUsageWriter.cs    | 1676 ++++++++++++-
 .../Writers/AutoGenWriters/BehaviorWriter.cs  |  813 ++++++-
 .../BindingConnectorAsUsageWriter.cs          | 1794 +++++++++++++-
 .../AutoGenWriters/BindingConnectorWriter.cs  | 1194 ++++++++-
 .../AutoGenWriters/BooleanExpressionWriter.cs | 1131 ++++++++-
 .../CalculationDefinitionWriter.cs            | 1443 ++++++++++-
 .../AutoGenWriters/CalculationUsageWriter.cs  | 1766 +++++++++++++-
 .../AutoGenWriters/CaseDefinitionWriter.cs    | 1488 +++++++++++-
 .../Writers/AutoGenWriters/CaseUsageWriter.cs | 1811 +++++++++++++-
 .../Writers/AutoGenWriters/ClassWriter.cs     |  796 +++++-
 .../AutoGenWriters/ClassifierWriter.cs        |  796 +++++-
 .../AutoGenWriters/CollectExpressionWriter.cs | 1182 ++++++++-
 .../Writers/AutoGenWriters/CommentWriter.cs   |  357 ++-
 .../AutoGenWriters/ConcernDefinitionWriter.cs | 1528 +++++++++++-
 .../AutoGenWriters/ConcernUsageWriter.cs      | 1868 ++++++++++++--
 .../ConjugatedPortDefinitionWriter.cs         | 1351 ++++++++++-
 .../ConjugatedPortTypingWriter.cs             |  358 ++-
 .../AutoGenWriters/ConjugationWriter.cs       |  344 ++-
 .../ConnectionDefinitionWriter.cs             | 1434 ++++++++++-
 .../AutoGenWriters/ConnectionUsageWriter.cs   | 1853 ++++++++++++--
 .../Writers/AutoGenWriters/ConnectorWriter.cs | 1194 ++++++++-
 .../ConstraintDefinitionWriter.cs             | 1407 ++++++++++-
 .../AutoGenWriters/ConstraintUsageWriter.cs   | 1749 +++++++++++++-
 .../ConstructorExpressionWriter.cs            | 1162 ++++++++-
 .../AutoGenWriters/CrossSubsettingWriter.cs   |  336 ++-
 .../Writers/AutoGenWriters/DataTypeWriter.cs  |  796 +++++-
 .../AutoGenWriters/DecisionNodeWriter.cs      | 1718 ++++++++++++-
 .../AutoGenWriters/DefinitionWriter.cs        | 1331 +++++++++-
 .../AutoGenWriters/DependencyWriter.cs        |  336 ++-
 .../AutoGenWriters/DifferencingWriter.cs      |  336 ++-
 .../AutoGenWriters/DisjoiningWriter.cs        |  344 ++-
 .../AutoGenWriters/DocumentationWriter.cs     |  354 ++-
 .../ElementFilterMembershipWriter.cs          |  383 ++-
 .../EndFeatureMembershipWriter.cs             |  383 ++-
 .../EnumerationDefinitionWriter.cs            | 1331 +++++++++-
 .../AutoGenWriters/EnumerationUsageWriter.cs  | 1673 ++++++++++++-
 .../EventOccurrenceUsageWriter.cs             | 1715 ++++++++++++-
 .../AutoGenWriters/ExhibitStateUsageWriter.cs | 1778 +++++++++++++-
 .../AutoGenWriters/ExpressionWriter.cs        | 1131 ++++++++-
 .../FeatureChainExpressionWriter.cs           | 1196 ++++++++-
 .../AutoGenWriters/FeatureChainingWriter.cs   |  336 ++-
 .../AutoGenWriters/FeatureInvertingWriter.cs  |  344 ++-
 .../AutoGenWriters/FeatureMembershipWriter.cs |  383 ++-
 .../FeatureReferenceExpressionWriter.cs       | 1145 ++++++++-
 .../AutoGenWriters/FeatureTypingWriter.cs     |  344 ++-
 .../AutoGenWriters/FeatureValueWriter.cs      |  409 +++-
 .../Writers/AutoGenWriters/FeatureWriter.cs   | 1091 ++++++++-
 .../AutoGenWriters/FlowDefinitionWriter.cs    | 1468 ++++++++++-
 .../Writers/AutoGenWriters/FlowEndWriter.cs   | 1091 ++++++++-
 .../Writers/AutoGenWriters/FlowUsageWriter.cs | 1912 +++++++++++++--
 .../Writers/AutoGenWriters/FlowWriter.cs      | 1270 +++++++++-
 .../ForLoopActionUsageWriter.cs               | 1760 +++++++++++++-
 .../Writers/AutoGenWriters/ForkNodeWriter.cs  | 1718 ++++++++++++-
 .../FramedConcernMembershipWriter.cs          |  402 +++-
 .../Writers/AutoGenWriters/FunctionWriter.cs  |  856 ++++++-
 .../AutoGenWriters/IfActionUsageWriter.cs     | 1760 +++++++++++++-
 .../IncludeUseCaseUsageWriter.cs              | 1842 +++++++++++++-
 .../AutoGenWriters/IndexExpressionWriter.cs   | 1182 ++++++++-
 .../AutoGenWriters/InteractionWriter.cs       |  906 ++++++-
 .../InterfaceDefinitionWriter.cs              | 1434 ++++++++++-
 .../AutoGenWriters/InterfaceUsageWriter.cs    | 1853 ++++++++++++--
 .../AutoGenWriters/IntersectingWriter.cs      |  336 ++-
 .../Writers/AutoGenWriters/InvariantWriter.cs | 1143 ++++++++-
 .../InvocationExpressionWriter.cs             | 1162 ++++++++-
 .../AutoGenWriters/ItemDefinitionWriter.cs    | 1343 ++++++++++-
 .../Writers/AutoGenWriters/ItemUsageWriter.cs | 1718 ++++++++++++-
 .../Writers/AutoGenWriters/JoinNodeWriter.cs  | 1718 ++++++++++++-
 .../AutoGenWriters/LibraryPackageWriter.cs    |  405 +++-
 .../AutoGenWriters/LiteralBooleanWriter.cs    | 1147 ++++++++-
 .../AutoGenWriters/LiteralExpressionWriter.cs | 1131 ++++++++-
 .../AutoGenWriters/LiteralInfinityWriter.cs   | 1131 ++++++++-
 .../AutoGenWriters/LiteralIntegerWriter.cs    | 1138 ++++++++-
 .../AutoGenWriters/LiteralRationalWriter.cs   | 1138 ++++++++-
 .../AutoGenWriters/LiteralStringWriter.cs     | 1147 ++++++++-
 .../AutoGenWriters/MembershipExposeWriter.cs  |  375 ++-
 .../AutoGenWriters/MembershipImportWriter.cs  |  375 ++-
 .../AutoGenWriters/MembershipWriter.cs        |  381 ++-
 .../Writers/AutoGenWriters/MergeNodeWriter.cs | 1718 ++++++++++++-
 .../Writers/AutoGenWriters/MetaclassWriter.cs |  796 +++++-
 .../MetadataAccessExpressionWriter.cs         | 1145 ++++++++-
 .../MetadataDefinitionWriter.cs               | 1343 ++++++++++-
 .../AutoGenWriters/MetadataFeatureWriter.cs   | 1162 ++++++++-
 .../AutoGenWriters/MetadataUsageWriter.cs     | 1797 +++++++++++++-
 .../AutoGenWriters/MultiplicityRangeWriter.cs | 1128 ++++++++-
 .../AutoGenWriters/MultiplicityWriter.cs      | 1091 ++++++++-
 .../AutoGenWriters/NamespaceExposeWriter.cs   |  375 ++-
 .../AutoGenWriters/NamespaceImportWriter.cs   |  375 ++-
 .../Writers/AutoGenWriters/NamespaceWriter.cs |  374 ++-
 .../AutoGenWriters/NullExpressionWriter.cs    | 1131 ++++++++-
 .../ObjectiveMembershipWriter.cs              |  383 ++-
 .../OccurrenceDefinitionWriter.cs             | 1343 ++++++++++-
 .../AutoGenWriters/OccurrenceUsageWriter.cs   | 1701 ++++++++++++-
 .../OperatorExpressionWriter.cs               | 1182 ++++++++-
 .../AutoGenWriters/OwningMembershipWriter.cs  |  383 ++-
 .../Writers/AutoGenWriters/PackageWriter.cs   |  391 ++-
 .../ParameterMembershipWriter.cs              |  383 ++-
 .../AutoGenWriters/PartDefinitionWriter.cs    | 1343 ++++++++++-
 .../Writers/AutoGenWriters/PartUsageWriter.cs | 1735 ++++++++++++-
 .../AutoGenWriters/PayloadFeatureWriter.cs    | 1091 ++++++++-
 .../PerformActionUsageWriter.cs               | 1732 ++++++++++++-
 .../AutoGenWriters/PortConjugationWriter.cs   |  344 ++-
 .../AutoGenWriters/PortDefinitionWriter.cs    | 1351 ++++++++++-
 .../Writers/AutoGenWriters/PortUsageWriter.cs | 1701 ++++++++++++-
 .../Writers/AutoGenWriters/PredicateWriter.cs |  856 ++++++-
 .../AutoGenWriters/RedefinitionWriter.cs      |  344 ++-
 .../ReferenceSubsettingWriter.cs              |  336 ++-
 .../AutoGenWriters/ReferenceUsageWriter.cs    | 1676 ++++++++++++-
 .../RenderingDefinitionWriter.cs              | 1360 ++++++++++-
 .../AutoGenWriters/RenderingUsageWriter.cs    | 1732 ++++++++++++-
 .../RequirementConstraintMembershipWriter.cs  |  402 +++-
 .../RequirementDefinitionWriter.cs            | 1528 +++++++++++-
 .../AutoGenWriters/RequirementUsageWriter.cs  | 1868 ++++++++++++--
 ...RequirementVerificationMembershipWriter.cs |  402 +++-
 .../ResultExpressionMembershipWriter.cs       |  383 ++-
 .../ReturnParameterMembershipWriter.cs        |  383 ++-
 .../SatisfyRequirementUsageWriter.cs          | 1900 +++++++++++++--
 .../AutoGenWriters/SelectExpressionWriter.cs  | 1182 ++++++++-
 .../AutoGenWriters/SendActionUsageWriter.cs   | 1760 +++++++++++++-
 .../AutoGenWriters/SpecializationWriter.cs    |  344 ++-
 .../StakeholderMembershipWriter.cs            |  383 ++-
 .../AutoGenWriters/StateDefinitionWriter.cs   | 1446 ++++++++++-
 .../StateSubactionMembershipWriter.cs         |  388 ++-
 .../AutoGenWriters/StateUsageWriter.cs        | 1764 +++++++++++++-
 .../Writers/AutoGenWriters/StepWriter.cs      | 1108 ++++++++-
 .../Writers/AutoGenWriters/StructureWriter.cs |  796 +++++-
 .../AutoGenWriters/SubclassificationWriter.cs |  344 ++-
 .../AutoGenWriters/SubjectMembershipWriter.cs |  383 ++-
 .../AutoGenWriters/SubsettingWriter.cs        |  344 ++-
 .../AutoGenWriters/SuccessionAsUsageWriter.cs | 1794 +++++++++++++-
 .../SuccessionFlowUsageWriter.cs              | 1912 +++++++++++++--
 .../AutoGenWriters/SuccessionFlowWriter.cs    | 1270 +++++++++-
 .../AutoGenWriters/SuccessionWriter.cs        | 1194 ++++++++-
 .../TerminateActionUsageWriter.cs             | 1732 ++++++++++++-
 .../TextualRepresentationWriter.cs            |  354 ++-
 .../TransitionFeatureMembershipWriter.cs      |  388 ++-
 .../AutoGenWriters/TransitionUsageWriter.cs   | 1811 +++++++++++++-
 .../TriggerInvocationExpressionWriter.cs      | 1171 ++++++++-
 .../AutoGenWriters/TypeFeaturingWriter.cs     |  344 ++-
 .../Writers/AutoGenWriters/TypeWriter.cs      |  779 +++++-
 .../Writers/AutoGenWriters/UnioningWriter.cs  |  336 ++-
 .../Writers/AutoGenWriters/UsageWriter.cs     | 1676 ++++++++++++-
 .../AutoGenWriters/UseCaseDefinitionWriter.cs | 1505 +++++++++++-
 .../AutoGenWriters/UseCaseUsageWriter.cs      | 1828 +++++++++++++-
 .../AutoGenWriters/VariantMembershipWriter.cs |  383 ++-
 .../VerificationCaseDefinitionWriter.cs       | 1505 +++++++++++-
 .../VerificationCaseUsageWriter.cs            | 1842 +++++++++++++-
 .../AutoGenWriters/ViewDefinitionWriter.cs    | 1408 ++++++++++-
 .../ViewRenderingMembershipWriter.cs          |  397 ++-
 .../Writers/AutoGenWriters/ViewUsageWriter.cs | 1797 +++++++++++++-
 .../ViewpointDefinitionWriter.cs              | 1545 +++++++++++-
 .../AutoGenWriters/ViewpointUsageWriter.cs    | 1885 +++++++++++++--
 .../WhileLoopActionUsageWriter.cs             | 1760 +++++++++++++-
 .../AutoGenWriters/XmiDataWriterFacade.cs     | 2137 ++++++++++++++---
 .../Writers/IXmiDataWriterFacade.cs           |   41 +-
 .../Writers/XmiDataWriter.cs                  |  101 +
 203 files changed, 174961 insertions(+), 13961 deletions(-)
 create mode 100644 SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-async-template.hbs
 create mode 100644 SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-async-template.hbs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/XmiDataWriter.cs

diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AnnotatingElementReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AnnotatingElementReader.cs
index c61ad6030..29b22f2cd 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AnnotatingElementReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AnnotatingElementReader.cs
@@ -61,7 +61,8 @@ public class AnnotatingElementReader : XmiDataReader<IAnnotatingElement>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AnnotatingElementReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public AnnotatingElementReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AnnotatingElementReader>.Instance : loggerFactory.CreateLogger<AnnotatingElementReader>();
         }
@@ -107,6 +108,8 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AnnotatingElement", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -257,7 +260,7 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -278,7 +281,7 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -335,6 +338,8 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "AnnotatingElement", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -485,7 +490,7 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -506,7 +511,7 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AssociationReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AssociationReader.cs
index 8216d7169..c0d7c1a5c 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AssociationReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AssociationReader.cs
@@ -65,7 +65,8 @@ public class AssociationReader : XmiDataReader<IAssociation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public AssociationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public AssociationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AssociationReader>.Instance : loggerFactory.CreateLogger<AssociationReader>();
         }
@@ -111,6 +112,8 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Association", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -357,7 +360,7 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -378,7 +381,7 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -399,7 +402,7 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -420,7 +423,7 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -477,6 +480,8 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Association", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -723,7 +728,7 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -744,7 +749,7 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -765,7 +770,7 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -786,7 +791,7 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/DependencyReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/DependencyReader.cs
index 1264907be..2d8a36e74 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/DependencyReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/DependencyReader.cs
@@ -62,7 +62,8 @@ public class DependencyReader : XmiDataReader<IDependency>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public DependencyReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public DependencyReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DependencyReader>.Instance : loggerFactory.CreateLogger<DependencyReader>();
         }
@@ -108,6 +109,8 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Dependency", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -290,7 +293,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var clientValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var clientValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Client.Add(clientValue);
                                     }
@@ -371,7 +374,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -392,7 +395,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -413,7 +416,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -434,7 +437,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -455,7 +458,7 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var supplierValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var supplierValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Supplier.Add(supplierValue);
                                     }
@@ -512,6 +515,8 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Dependency", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -694,7 +699,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var clientValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var clientValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Client.Add(clientValue);
                                     }
@@ -775,7 +780,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -796,7 +801,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -817,7 +822,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -838,7 +843,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -859,7 +864,7 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var supplierValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var supplierValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Supplier.Add(supplierValue);
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/EnumerationDefinitionReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/EnumerationDefinitionReader.cs
index 32b744c87..c401061c9 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/EnumerationDefinitionReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/EnumerationDefinitionReader.cs
@@ -86,7 +86,8 @@ public class EnumerationDefinitionReader : XmiDataReader<IEnumerationDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public EnumerationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public EnumerationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<EnumerationDefinitionReader>.Instance : loggerFactory.CreateLogger<EnumerationDefinitionReader>();
         }
@@ -132,6 +133,8 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "EnumerationDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -348,7 +351,7 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -369,7 +372,7 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -426,6 +429,8 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "EnumerationDefinition", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -642,7 +647,7 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -663,7 +668,7 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureReader.cs
index 420b09617..f1a8d5f0d 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureReader.cs
@@ -64,7 +64,8 @@ public class FeatureReader : XmiDataReader<IFeature>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public FeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureReader>.Instance : loggerFactory.CreateLogger<FeatureReader>();
         }
@@ -110,6 +111,8 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Feature", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -502,7 +505,7 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -523,7 +526,7 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -580,6 +583,8 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Feature", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -972,7 +977,7 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -993,7 +998,7 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureTypingReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureTypingReader.cs
index 98c1a7336..db61c6395 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureTypingReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureTypingReader.cs
@@ -63,7 +63,8 @@ public class FeatureTypingReader : XmiDataReader<IFeatureTyping>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FeatureTypingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public FeatureTypingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureTypingReader>.Instance : loggerFactory.CreateLogger<FeatureTypingReader>();
         }
@@ -109,6 +110,8 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureTyping", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -331,7 +334,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -352,7 +355,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -373,7 +376,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -394,7 +397,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -415,7 +418,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var typeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typeValue = (IType)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Type = typeValue;
                                     }
@@ -436,7 +439,7 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var typedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.TypedFeature = typedFeatureValue;
                                     }
@@ -493,6 +496,8 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FeatureTyping", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -715,7 +720,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -736,7 +741,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -757,7 +762,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -778,7 +783,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -799,7 +804,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var typeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typeValue = (IType)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Type = typeValue;
                                     }
@@ -820,7 +825,7 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     }
                                     else
                                     {
-                                        var typedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var typedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.TypedFeature = typedFeatureValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FlowReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FlowReader.cs
index f0c0083bc..6879e1fd2 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FlowReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FlowReader.cs
@@ -69,7 +69,8 @@ public class FlowReader : XmiDataReader<IFlow>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FlowReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public FlowReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FlowReader>.Instance : loggerFactory.CreateLogger<FlowReader>();
         }
@@ -115,6 +116,8 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Flow", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -559,7 +562,7 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -580,7 +583,7 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -601,7 +604,7 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -622,7 +625,7 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -679,6 +682,8 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Flow", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1123,7 +1128,7 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -1144,7 +1149,7 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1165,7 +1170,7 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -1186,7 +1191,7 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FramedConcernMembershipReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FramedConcernMembershipReader.cs
index aec6ea208..2723db6d3 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FramedConcernMembershipReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FramedConcernMembershipReader.cs
@@ -67,7 +67,8 @@ public class FramedConcernMembershipReader : XmiDataReader<IFramedConcernMembers
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public FramedConcernMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public FramedConcernMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FramedConcernMembershipReader>.Instance : loggerFactory.CreateLogger<FramedConcernMembershipReader>();
         }
@@ -113,6 +114,8 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FramedConcernMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -347,7 +350,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -368,7 +371,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -389,7 +392,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -410,7 +413,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -479,6 +482,8 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "FramedConcernMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -713,7 +718,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -734,7 +739,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -755,7 +760,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -776,7 +781,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralIntegerReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralIntegerReader.cs
index ee51eea31..d2bd9f22d 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralIntegerReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralIntegerReader.cs
@@ -67,7 +67,8 @@ public class LiteralIntegerReader : XmiDataReader<ILiteralInteger>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public LiteralIntegerReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public LiteralIntegerReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralIntegerReader>.Instance : loggerFactory.CreateLogger<LiteralIntegerReader>();
         }
@@ -113,6 +114,8 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralInteger", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -515,7 +518,7 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -536,7 +539,7 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -605,6 +608,8 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralInteger", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1007,7 +1012,7 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1028,7 +1033,7 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralRationalReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralRationalReader.cs
index de420df3a..583ee0fd8 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralRationalReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralRationalReader.cs
@@ -67,7 +67,8 @@ public class LiteralRationalReader : XmiDataReader<ILiteralRational>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public LiteralRationalReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public LiteralRationalReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralRationalReader>.Instance : loggerFactory.CreateLogger<LiteralRationalReader>();
         }
@@ -113,6 +114,8 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralRational", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -515,7 +518,7 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -536,7 +539,7 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -605,6 +608,8 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "LiteralRational", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1007,7 +1012,7 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1028,7 +1033,7 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MembershipReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MembershipReader.cs
index 5a78c2a75..7437fb907 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MembershipReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MembershipReader.cs
@@ -62,7 +62,8 @@ public class MembershipReader : XmiDataReader<IMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public MembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MembershipReader>.Instance : loggerFactory.CreateLogger<MembershipReader>();
         }
@@ -108,6 +109,8 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Membership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -344,7 +347,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var memberElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var memberElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.MemberElement = memberElementValue;
                                     }
@@ -389,7 +392,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -410,7 +413,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -431,7 +434,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -452,7 +455,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -521,6 +524,8 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Membership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -757,7 +762,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var memberElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var memberElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.MemberElement = memberElementValue;
                                     }
@@ -802,7 +807,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -823,7 +828,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -844,7 +849,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -865,7 +870,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MultiplicityRangeReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MultiplicityRangeReader.cs
index 240d7cb9b..de0bbd2aa 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MultiplicityRangeReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MultiplicityRangeReader.cs
@@ -66,7 +66,8 @@ public class MultiplicityRangeReader : XmiDataReader<IMultiplicityRange>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public MultiplicityRangeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public MultiplicityRangeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MultiplicityRangeReader>.Instance : loggerFactory.CreateLogger<MultiplicityRangeReader>();
         }
@@ -112,6 +113,8 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MultiplicityRange", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -504,7 +507,7 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -525,7 +528,7 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -582,6 +585,8 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "MultiplicityRange", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -974,7 +979,7 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -995,7 +1000,7 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/OwningMembershipReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/OwningMembershipReader.cs
index 43aa08144..c04f8ba78 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/OwningMembershipReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/OwningMembershipReader.cs
@@ -62,7 +62,8 @@ public class OwningMembershipReader : XmiDataReader<IOwningMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public OwningMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public OwningMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<OwningMembershipReader>.Instance : loggerFactory.CreateLogger<OwningMembershipReader>();
         }
@@ -108,6 +109,8 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "OwningMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -320,7 +323,7 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -341,7 +344,7 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -362,7 +365,7 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -383,7 +386,7 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -452,6 +455,8 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "OwningMembership", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -664,7 +669,7 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -685,7 +690,7 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -706,7 +711,7 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -727,7 +732,7 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/ReferenceSubsettingReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/ReferenceSubsettingReader.cs
index 1dac13566..2914a19b2 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/ReferenceSubsettingReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/ReferenceSubsettingReader.cs
@@ -63,7 +63,8 @@ public class ReferenceSubsettingReader : XmiDataReader<IReferenceSubsetting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public ReferenceSubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public ReferenceSubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ReferenceSubsettingReader>.Instance : loggerFactory.CreateLogger<ReferenceSubsettingReader>();
         }
@@ -109,6 +110,8 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ReferenceSubsetting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -321,7 +324,7 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -342,7 +345,7 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -363,7 +366,7 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -384,7 +387,7 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -405,7 +408,7 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     }
                                     else
                                     {
-                                        var referencedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var referencedFeatureValue = (IFeature)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ReferencedFeature = referencedFeatureValue;
                                     }
@@ -462,6 +465,8 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "ReferenceSubsetting", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -674,7 +679,7 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -695,7 +700,7 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -716,7 +721,7 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -737,7 +742,7 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -758,7 +763,7 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     }
                                     else
                                     {
-                                        var referencedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var referencedFeatureValue = (IFeature)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.ReferencedFeature = referencedFeatureValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/RequirementUsageReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/RequirementUsageReader.cs
index c0014714f..a84d9989f 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/RequirementUsageReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/RequirementUsageReader.cs
@@ -91,7 +91,8 @@ public class RequirementUsageReader : XmiDataReader<IRequirementUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public RequirementUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public RequirementUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RequirementUsageReader>.Instance : loggerFactory.CreateLogger<RequirementUsageReader>();
         }
@@ -137,6 +138,8 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RequirementUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -549,7 +552,7 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -570,7 +573,7 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -651,6 +654,8 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "RequirementUsage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1063,7 +1068,7 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1084,7 +1089,7 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SelectExpressionReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SelectExpressionReader.cs
index 772f007e1..683c69458 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SelectExpressionReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SelectExpressionReader.cs
@@ -67,7 +67,8 @@ public class SelectExpressionReader : XmiDataReader<ISelectExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SelectExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public SelectExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SelectExpressionReader>.Instance : loggerFactory.CreateLogger<SelectExpressionReader>();
         }
@@ -113,6 +114,8 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SelectExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -524,7 +527,7 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -545,7 +548,7 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -602,6 +605,8 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "SelectExpression", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -1013,7 +1018,7 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1034,7 +1039,7 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SubclassificationReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SubclassificationReader.cs
index f33076269..592af9d80 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SubclassificationReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SubclassificationReader.cs
@@ -63,7 +63,8 @@ public class SubclassificationReader : XmiDataReader<ISubclassification>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public SubclassificationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public SubclassificationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SubclassificationReader>.Instance : loggerFactory.CreateLogger<SubclassificationReader>();
         }
@@ -109,6 +110,8 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Subclassification", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -331,7 +334,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -352,7 +355,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -373,7 +376,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -394,7 +397,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -415,7 +418,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var subclassifierValue = (IClassifier)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var subclassifierValue = (IClassifier)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Subclassifier = subclassifierValue;
                                     }
@@ -436,7 +439,7 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     }
                                     else
                                     {
-                                        var superclassifierValue = (IClassifier)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var superclassifierValue = (IClassifier)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Superclassifier = superclassifierValue;
                                     }
@@ -493,6 +496,8 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Subclassification", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -715,7 +720,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwnedRelatedElement.Add(ownedRelatedElementValue);
                                     }
@@ -736,7 +741,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -757,7 +762,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelatedElementValue = (IElement)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedRelationship)poco).OwningRelatedElement = owningRelatedElementValue;
                                     }
@@ -778,7 +783,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -799,7 +804,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var subclassifierValue = (IClassifier)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var subclassifierValue = (IClassifier)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Subclassifier = subclassifierValue;
                                     }
@@ -820,7 +825,7 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     }
                                     else
                                     {
-                                        var superclassifierValue = (IClassifier)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var superclassifierValue = (IClassifier)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         poco.Superclassifier = superclassifierValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/TextualRepresentationReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/TextualRepresentationReader.cs
index c9a2ddab9..f97035a71 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/TextualRepresentationReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/TextualRepresentationReader.cs
@@ -61,7 +61,8 @@ public class TextualRepresentationReader : XmiDataReader<ITextualRepresentation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public TextualRepresentationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public TextualRepresentationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TextualRepresentationReader>.Instance : loggerFactory.CreateLogger<TextualRepresentationReader>();
         }
@@ -107,6 +108,8 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TextualRepresentation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -295,7 +298,7 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -316,7 +319,7 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -373,6 +376,8 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "TextualRepresentation", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -561,7 +566,7 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -582,7 +587,7 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/UsageReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/UsageReader.cs
index a91ef454f..076911158 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/UsageReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/UsageReader.cs
@@ -87,7 +87,8 @@ public class UsageReader : XmiDataReader<IUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
-        public UsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory)
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
+        public UsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<UsageReader>.Instance : loggerFactory.CreateLogger<UsageReader>();
         }
@@ -133,6 +134,8 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Usage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -525,7 +528,7 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -546,7 +549,7 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)this.XmiDataReaderFacade.QueryXmiData(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
@@ -603,6 +606,8 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                     this.logger.LogCritical("Failed to add element type [{Poco}] with id [{Id}] as it was already in the Cache. The XMI document seems to have duplicate xmi:id values", "Usage", poco.Id);
                 }
 
+                this.ElementOriginMap?.Register(poco.Id, currentLocation);
+
                 var aliasIdsXmlAttribute = xmiReader.GetAttribute("aliasIds");
 
                 if (!string.IsNullOrWhiteSpace(aliasIdsXmlAttribute))
@@ -995,7 +1000,7 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     }
                                     else
                                     {
-                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var ownedRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwnedRelationship.Add(ownedRelationshipValue);
                                     }
@@ -1016,7 +1021,7 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     }
                                     else
                                     {
-                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory);
+                                        var owningRelationshipValue = (IRelationship)await this.XmiDataReaderFacade.QueryXmiDataAsync(xmiReader, this.Cache, currentLocation, this.ExternalReferenceService, this.LoggerFactory, elementOriginMap: this.ElementOriginMap);
 
                                         ((IContainedElement)poco).OwningRelationship = owningRelationshipValue;
                                     }
diff --git a/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs b/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs
index 17127eea4..61e1ba1d5 100644
--- a/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs
+++ b/SysML2.NET.CodeGenerator/Generators/UmlHandleBarsGenerators/UmlCoreXmiWriterGenerator.cs
@@ -187,6 +187,8 @@ protected override void RegisterTemplates()
             this.RegisterTemplate(XmiWriterFacadeTemplateName);
             this.RegisterPartialTemplate("core-xmi-writer-partial-for-attribute-template");
             this.RegisterPartialTemplate("core-xmi-writer-partial-for-element-template");
+            this.RegisterPartialTemplate("core-xmi-writer-partial-for-attribute-async-template");
+            this.RegisterPartialTemplate("core-xmi-writer-partial-for-element-async-template");
         }
     }
 }
diff --git a/SysML2.NET.CodeGenerator/HandleBarHelpers/ClassHelper.cs b/SysML2.NET.CodeGenerator/HandleBarHelpers/ClassHelper.cs
index 53140d8d3..3446e7354 100644
--- a/SysML2.NET.CodeGenerator/HandleBarHelpers/ClassHelper.cs
+++ b/SysML2.NET.CodeGenerator/HandleBarHelpers/ClassHelper.cs
@@ -195,6 +195,16 @@ public static void RegisterClassHelper(this IHandlebars handlebars)
                 var properties = umlClass.QueryAllProperties();
                 return properties.Where(x => x.IsComposite && !x.IsDerived);
             });
+
+            handlebars.RegisterHelper("Class.QueryAllPropertiesSorted", (context, _) =>
+            {
+                if (context.Value is not IClass umlClass)
+                {
+                    throw new ArgumentException("Class.QueryAllPropertiesSorted context supposed to be IClass");
+                }
+
+                return umlClass.QueryAllProperties().OrderBy(x => x.Name);
+            });
         }
     }
 }
diff --git a/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs b/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs
index 85f8861ce..93eb6b4a3 100644
--- a/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs
+++ b/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs
@@ -1016,6 +1016,16 @@ public static void RegisterPropertyHelper(this IHandlebars handlebars)
                 return property.Type.Name == "Element";
             });
 
+            handlebars.RegisterHelper("Property.QueryIsImpliedIncluded", (_, arguments) =>
+            {
+                if (arguments.Single() is not IProperty property)
+                {
+                    throw new ArgumentException("The #Property.QueryIsImpliedIncluded argument supposed to be IProperty");
+                }
+
+                return property.Name == "isImpliedIncluded";
+            });
+
             handlebars.RegisterHelper("Property.WriteForNonDerivedCompositeAggregation", (writer, context, _) =>
             {
                 if (context.Value is not IProperty property)
diff --git a/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj b/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj
index fc0403b0b..a3dafa207 100644
--- a/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj
+++ b/SysML2.NET.CodeGenerator/SysML2.NET.CodeGenerator.csproj
@@ -223,6 +223,12 @@
     <None Update="Templates\Uml\Partials\core-xmi-writer-partial-for-element-template.hbs">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <None Update="Templates\Uml\Partials\core-xmi-writer-partial-for-attribute-async-template.hbs">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="Templates\Uml\Partials\core-xmi-writer-partial-for-element-async-template.hbs">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Resources\HtmlDocs\" />
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-async-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-async-template.hbs
new file mode 100644
index 000000000..55ec70b8f
--- /dev/null
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-async-template.hbs
@@ -0,0 +1,36 @@
+{{#if (Property.QueryIsEnumerable property)}}
+    {{#if (Property.QueryIsBool property)}}
+        if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
+        {
+            await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, string.Join(" ", poco.{{Property.WritePropertyName property}}));
+        }
+    {{else}}
+        if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
+        {
+            await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, string.Join(" ", poco.{{Property.WritePropertyName property}}));
+        }
+    {{/if}}
+{{else}}
+    {{#if (Property.QueryIsBool property)}}
+        {{#if (Property.QueryIsImpliedIncluded property)}}
+        if(includesImplied || poco.IsImpliedIncluded)
+        {
+            await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+        }
+        {{else}}
+        if(poco.{{Property.WritePropertyName property}})
+        {
+            await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, "true");
+        }
+        {{/if}}
+    {{else if (Property.QueryIsEnum property)}}
+        await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}}.ToString());
+    {{else if (Property.QueryIsNumeric property)}}
+        await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}}.ToString(CultureInfo.InvariantCulture));
+    {{else}}
+        if(!string.IsNullOrWhiteSpace(poco.{{Property.WritePropertyName property}}))
+        {
+            await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}});
+        }
+    {{/if}}
+{{/if}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs
index 663b2a1fd..b51f930f3 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs
@@ -12,10 +12,17 @@
     {{/if}}
 {{else}}
     {{#if (Property.QueryIsBool property)}}
+        {{#if (Property.QueryIsImpliedIncluded property)}}
+        if(includesImplied || poco.IsImpliedIncluded)
+        {
+            xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+        }
+        {{else}}
         if(poco.{{Property.WritePropertyName property}})
         {
             xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", "true");
         }
+        {{/if}}
     {{else if (Property.QueryIsEnum property)}}
         xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}}.ToString());
     {{else if (Property.QueryIsNumeric property)}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-async-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-async-template.hbs
new file mode 100644
index 000000000..9a0efebfd
--- /dev/null
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-async-template.hbs
@@ -0,0 +1,22 @@
+{{#if (Property.QueryIsEnumerable property)}}
+    if(poco.{{Property.WritePropertyName property}} != null)
+    {
+        foreach(var item in poco.{{Property.WritePropertyName property}})
+        {
+            {{#if property.IsComposite}}
+                await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+            {{else}}
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
+            {{/if}}
+        }
+    }
+{{else}}
+    if(poco.{{Property.WritePropertyName property}} != null)
+    {
+        {{#if property.IsComposite}}
+            await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+        {{else}}
+            await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
+        {{/if}}
+    }
+{{/if}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs
index 83ed4836b..b086fdcdb 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs
@@ -4,9 +4,9 @@
         foreach(var item in poco.{{Property.WritePropertyName property}})
         {
             {{#if property.IsComposite}}
-                xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
             {{else}}
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
             {{/if}}
         }
     }
@@ -14,9 +14,9 @@
     if(poco.{{Property.WritePropertyName property}} != null)
     {
         {{#if property.IsComposite}}
-            xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, elementOriginMap, currentFileUri);
+            this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
         {{else}}
-            xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
+            this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
         {{/if}}
     }
 {{/if}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
index da497725d..09ae3f4d1 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
@@ -26,32 +26,62 @@ namespace SysML2.NET.Serializer.Xmi.Writers
 {
     using System;
     using System.Collections.Generic;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="XmiDataWriterFacade"/> is to dispatch writing of <see cref="IData"/> instances
-    /// to the appropriate per-type static writer class
+    /// to the appropriate per-type writer class
     /// </summary>
     public class XmiDataWriterFacade : IXmiDataWriterFacade
     {
+        /// <summary>
+        /// The <see cref="ILoggerFactory"/> used to set up logging for writer instances
+        /// </summary>
+        private readonly ILoggerFactory loggerFactory;
+
         /// <summary>
         /// A dictionary that contains actions that write <see cref="IData"/> based on a key that represents the POCO type name
         /// </summary>
-        private readonly Dictionary<string, Action<XmlWriter, IData, string, bool, IXmiDataWriterFacade, IXmiElementOriginMap, Uri>> writerCache;
+        private readonly Dictionary<string, Action<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri>> writerCache;
+
+        /// <summary>
+        /// A dictionary that contains functions that asynchronously write <see cref="IData"/> based on a key that represents the POCO type name
+        /// </summary>
+        private readonly Dictionary<string, Func<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri, Task>> writerAsyncCache;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="XmiDataWriterFacade"/>
         /// </summary>
-        public XmiDataWriterFacade()
+        /// <param name="loggerFactory">The <see cref="ILoggerFactory"/> used to set up logging</param>
+        public XmiDataWriterFacade(ILoggerFactory loggerFactory)
         {
-            this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, bool, IXmiDataWriterFacade, IXmiElementOriginMap, Uri>>
+            this.loggerFactory = loggerFactory;
+
+            this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri>>
             {
             {{ #each this as | class | }}
-                ["{{ class.Name }}"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    {{ class.Name }}Writer.Write(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, includeDerived, facade, originMap, uri),
+                ["{{ class.Name }}"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new {{ class.Name }}Writer(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+            {{/each}}
+            };
+
+            this.writerAsyncCache = new Dictionary<string, Func<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri, Task>>
+            {
+            {{ #each this as | class | }}
+                ["{{ class.Name }}"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new {{ class.Name }}Writer(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
             {{/each}}
             };
         }
@@ -65,13 +95,13 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             var typeName = data.GetType().Name;
 
             if (this.writerCache.TryGetValue(typeName, out var writer))
             {
-                writer(xmlWriter, data, elementName, includeDerivedProperties, this, elementOriginMap, currentFileUri);
+                writer(xmlWriter, data, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
             }
             else
             {
@@ -88,8 +118,13 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
         {
+            if (!includesImplied && childData is IRelationship rel && rel.IsImplied)
+            {
+                return;
+            }
+
             if (elementOriginMap != null && currentFileUri != null)
             {
                 var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
@@ -101,7 +136,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
                 }
             }
 
-            this.Write(xmlWriter, childData, elementName, includeDerivedProperties, elementOriginMap, currentFileUri);
+            this.Write(xmlWriter, childData, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
         }
 
         /// <summary>
@@ -130,6 +165,85 @@ namespace SysML2.NET.Serializer.Xmi.Writers
             xmlWriter.WriteEndElement();
         }
 
+        /// <summary>
+        /// Asynchronously writes the specified <see cref="IData"/> as an XMI element by dispatching to the appropriate per-type writer
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="data">The <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public async Task WriteAsync(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            var typeName = data.GetType().Name;
+
+            if (this.writerAsyncCache.TryGetValue(typeName, out var writer))
+            {
+                await writer(xmlWriter, data, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+            }
+            else
+            {
+                throw new InvalidOperationException($"No writer found for type {typeName}");
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously writes a contained child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public async Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (!includesImplied && childData is IRelationship rel && rel.IsImplied)
+            {
+                return;
+            }
+
+            if (elementOriginMap != null && currentFileUri != null)
+            {
+                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
+
+                if (childSourceFile != null && childSourceFile != currentFileUri)
+                {
+                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    return;
+                }
+            }
+
+            await this.WriteAsync(xmlWriter, childData, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a reference child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public async Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (elementOriginMap != null && currentFileUri != null)
+            {
+                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
+
+                if (childSourceFile != null && childSourceFile != currentFileUri)
+                {
+                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    return;
+                }
+            }
+
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xmi", "idref", null, childData.Id.ToString());
+            await xmlWriter.WriteEndElementAsync();
+        }
+
         /// <summary>
         /// Writes an href element for cross-file references
         /// </summary>
@@ -142,6 +256,19 @@ namespace SysML2.NET.Serializer.Xmi.Writers
             xmlWriter.WriteAttributeString("href", href);
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes an href element for cross-file references
+        /// </summary>
+        private static async Task WriteHrefElementAsync(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile)
+        {
+            var relativePath = currentFile.MakeRelativeUri(targetFile);
+            var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{childData.Id}";
+
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync(null, "href", null, href);
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
index 942382b95..b2d79bb55 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     {{ #Class.WriteEnumerationNameSpaces this}}
     {{ #Class.WriteNameSpaces this POCO}}
@@ -39,8 +43,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="{{this.Name}}Writer" /> is to write an instance of <see cref="I{{this.Name}}" />
     /// to the XMI document
     /// </summary>
-    public static class {{this.Name}}Writer
+    public class {{this.Name}}Writer : XmiDataWriter<I{{this.Name}}>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<{{this.Name}}Writer> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="{{this.Name}}Writer" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public {{this.Name}}Writer(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<{{this.Name}}Writer>.Instance : loggerFactory.CreateLogger<{{this.Name}}Writer>();
+        }
+
         /// <summary>
         /// Writes the <see cref="I{{this.Name}}" /> object to its XML representation
         /// </summary>
@@ -48,82 +69,132 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="poco">The <see cref="I{{this.Name}}" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, I{{this.Name}} poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, I{{this.Name}} poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:{{this.Name}}");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             {{#with this as |class| }}
-                {{ #each (Class.QueryAllProperties this) as | property | }}
+                {{ #each (Class.QueryAllPropertiesSorted this) as | property | }}
                     {{#unless this.IsTransient}}
-                        {{#unless this.IsDerived}}
-                            {{#unless (Property.QueryIsReferenceProperty this)}}
-                                {{#unless (Property.IsPropertyRedefinedInClass this class)}}
+                        {{#unless (Property.QueryIsReferenceProperty this)}}
+                            {{#unless (Property.IsPropertyRedefinedInClass this class)}}
+                                {{#if this.IsDerived}}
+                                    if(includeDerivedProperties)
+                                    {
+                                        {{> core-xmi-writer-partial-for-attribute-template this}}
+                                    }
+                                {{else}}
                                     {{> core-xmi-writer-partial-for-attribute-template this}}
-                                {{/unless}}
+                                {{/if}}
+
                             {{/unless}}
                         {{/unless}}
                     {{/unless}}
                 {{/each}}
             {{/with}}
 
-            // Derived scalar properties
-            if(includeDerivedProperties)
-            {
-                {{#with this as |class| }}
-                    {{ #each (Class.QueryAllProperties this) as | property | }}
-                        {{#unless this.IsTransient}}
-                            {{#if this.IsDerived}}
-                                {{#unless (Property.QueryIsReferenceProperty this)}}
-                                    {{#unless (Property.IsPropertyRedefinedInClass this class)}}
-                                        {{> core-xmi-writer-partial-for-attribute-template this}}
-                                    {{/unless}}
-                                {{/unless}}
-                            {{/if}}
-                        {{/unless}}
-                    {{/each}}
-                {{/with}}
-            }
-
-            // Reference/containment properties as child elements
+            // Reference/containment properties as child elements (sorted alphabetically)
             {{#with this as |class| }}
-                {{ #each (Class.QueryAllProperties this) as | property | }}
+                {{ #each (Class.QueryAllPropertiesSorted this) as | property | }}
                     {{#unless this.IsTransient}}
-                        {{#unless this.IsDerived}}
-                            {{#if (Property.QueryIsReferenceProperty this)}}
-                                {{#unless (Property.IsPropertyRedefinedInClass this class)}}
+                        {{#if (Property.QueryIsReferenceProperty this)}}
+                            {{#unless (Property.IsPropertyRedefinedInClass this class)}}
+                                {{#if this.IsDerived}}
+                                    if(includeDerivedProperties)
+                                    {
+                                        {{> core-xmi-writer-partial-for-element-template this}}
+                                    }
+                                {{else}}
                                     {{> core-xmi-writer-partial-for-element-template this}}
-                                {{/unless}}
-                            {{/if}}
-                        {{/unless}}
+                                {{/if}}
+                                
+                            {{/unless}}
+                        {{/if}}
                     {{/unless}}
                 {{/each}}
             {{/with}}
 
-            // Derived reference/containment properties as child elements
-            if(includeDerivedProperties)
-            {
-                {{#with this as |class| }}
-                    {{ #each (Class.QueryAllProperties this) as | property | }}
-                        {{#unless this.IsTransient}}
-                            {{#if this.IsDerived}}
-                                {{#if (Property.QueryIsReferenceProperty this)}}
-                                    {{#unless (Property.IsPropertyRedefinedInClass this class)}}
-                                        {{> core-xmi-writer-partial-for-element-template this}}
-                                    {{/unless}}
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="I{{this.Name}}" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="I{{this.Name}}" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, I{{this.Name}} poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:{{this.Name}}");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            {{#with this as |class| }}
+                {{ #each (Class.QueryAllPropertiesSorted this) as | property | }}
+                    {{#unless this.IsTransient}}
+                        {{#unless (Property.QueryIsReferenceProperty this)}}
+                            {{#unless (Property.IsPropertyRedefinedInClass this class)}}
+                                {{#if this.IsDerived}}
+                                    if(includeDerivedProperties)
+                                    {
+                                        {{> core-xmi-writer-partial-for-attribute-async-template this}}
+                                    }
+                                {{else}}
+                                    {{> core-xmi-writer-partial-for-attribute-async-template this}}
                                 {{/if}}
-                            {{/if}}
+
+                            {{/unless}}
                         {{/unless}}
-                    {{/each}}
-                {{/with}}
-            }
+                    {{/unless}}
+                {{/each}}
+            {{/with}}
 
-            xmlWriter.WriteEndElement();
+            // Reference/containment properties as child elements (sorted alphabetically)
+            {{#with this as |class| }}
+                {{ #each (Class.QueryAllPropertiesSorted this) as | property | }}
+                    {{#unless this.IsTransient}}
+                        {{#if (Property.QueryIsReferenceProperty this)}}
+                            {{#unless (Property.IsPropertyRedefinedInClass this class)}}
+                                {{#if this.IsDerived}}
+                                    if(includeDerivedProperties)
+                                    {
+                                        {{> core-xmi-writer-partial-for-element-async-template this}}
+                                    }
+                                {{else}}
+                                    {{> core-xmi-writer-partial-for-element-async-template this}}
+                                {{/if}}
+
+                            {{/unless}}
+                        {{/if}}
+                    {{/unless}}
+                {{/each}}
+            {{/with}}
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
index 8a78d1959..2694e6145 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
@@ -100,7 +100,7 @@ public void Verify_that_serialized_output_is_well_formed_xml_with_correct_root()
             var serializer = new Serializer(this.loggerFactory);
             var memoryStream = new MemoryStream();
 
-            serializer.Serialize(originalNamespace, false, memoryStream);
+            serializer.Serialize(originalNamespace, false, false, memoryStream);
 
             Assert.That(memoryStream.Length, Is.GreaterThan(0));
 
diff --git a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
index e4756b9fb..5babb1b0d 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
@@ -22,9 +22,11 @@ namespace SysML2.NET.Serializer.Xmi.Tests
 {
     using System;
     using System.IO;
+    using System.Linq;
     using System.Threading;
     using System.Threading.Tasks;
 
+    using Core.POCO.Root.Elements;
     using Core.POCO.Root.Namespaces;
 
     using Microsoft.Extensions.DependencyInjection;
@@ -63,7 +65,7 @@ public void Verify_that_the_name_space_can_be_serialized_to_xmi()
         {
             var targetStream = new MemoryStream();
 
-            Assert.That(() => this.serializer.Serialize(this.anonymouseNameSpace, false, targetStream), Throws.Nothing);
+            Assert.That(() => this.serializer.Serialize(this.anonymouseNameSpace, false, false, targetStream), Throws.Nothing);
 
             Assert.That(targetStream.Length, Is.GreaterThan(0));
         }
@@ -73,7 +75,7 @@ public void Verify_that_serialized_xmi_contains_expected_structure()
         {
             var targetStream = new MemoryStream();
 
-            this.serializer.Serialize(this.anonymouseNameSpace, false, targetStream);
+            this.serializer.Serialize(this.anonymouseNameSpace, false, false, targetStream);
 
             targetStream.Seek(0, SeekOrigin.Begin);
             var reader = new StreamReader(targetStream);
@@ -90,11 +92,62 @@ public async Task Verify_that_the_name_space_can_be_serialized_to_xmi_async()
         {
             var targetStream = new MemoryStream();
 
-            await this.serializer.SerializeAsync(this.anonymouseNameSpace, false, targetStream, CancellationToken.None);
+            await this.serializer.SerializeAsync(this.anonymouseNameSpace, false, false, targetStream, CancellationToken.None);
 
             Assert.That(targetStream.Length, Is.GreaterThan(0));
         }
 
+        [Test]
+        public void Verify_that_includesImplied_false_excludes_implied_relationships()
+        {
+            var impliedRelationship = this.anonymouseNameSpace.OwnedRelationship.FirstOrDefault();
+            Assert.That(impliedRelationship, Is.Not.Null, "Need at least one relationship to test");
+
+            impliedRelationship.IsImplied = true;
+            var impliedId = impliedRelationship.Id.ToString();
+
+            var targetStream = new MemoryStream();
+            this.serializer.Serialize(this.anonymouseNameSpace, false, false, targetStream);
+
+            targetStream.Seek(0, SeekOrigin.Begin);
+            var content = new StreamReader(targetStream).ReadToEnd();
+
+            Assert.That(content, Does.Not.Contain(impliedId), "Implied relationship should be excluded when includesImplied=false");
+            Assert.That(content, Does.Not.Contain("isImpliedIncluded=\"true\""), "No element should have isImpliedIncluded=true when includesImplied=false");
+        }
+
+        [Test]
+        public void Verify_that_includesImplied_true_includes_implied_and_sets_isImpliedIncluded()
+        {
+            var impliedRelationship = this.anonymouseNameSpace.OwnedRelationship.FirstOrDefault();
+            Assert.That(impliedRelationship, Is.Not.Null, "Need at least one relationship to test");
+
+            impliedRelationship.IsImplied = true;
+            impliedRelationship.IsImpliedIncluded = false;
+
+            var targetStream = new MemoryStream();
+            this.serializer.Serialize(this.anonymouseNameSpace, false, true, targetStream);
+
+            targetStream.Seek(0, SeekOrigin.Begin);
+            var content = new StreamReader(targetStream).ReadToEnd();
+
+            Assert.That(content, Does.Contain("isImpliedIncluded=\"true\""), "All elements should have isImpliedIncluded=true when includesImplied=true");
+        }
+
+        [Test]
+        public void Verify_that_includesImplied_false_uses_per_element_isImpliedIncluded()
+        {
+            this.anonymouseNameSpace.IsImpliedIncluded = true;
+
+            var targetStream = new MemoryStream();
+            this.serializer.Serialize(this.anonymouseNameSpace, false, false, targetStream);
+
+            targetStream.Seek(0, SeekOrigin.Begin);
+            var content = new StreamReader(targetStream).ReadToEnd();
+
+            Assert.That(content, Does.Contain("isImpliedIncluded=\"true\""), "Root namespace with IsImpliedIncluded=true should appear in output");
+        }
+
         private void ReadAndAssemblePopulationFromXmiFile()
         {
             var filePath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "Domain Libraries", "Quantities and Units", "Quantities.sysmlx");
diff --git a/SysML2.NET.Serializer.Xmi/ISerializer.cs b/SysML2.NET.Serializer.Xmi/ISerializer.cs
index 263b17a30..7ead9ea82 100644
--- a/SysML2.NET.Serializer.Xmi/ISerializer.cs
+++ b/SysML2.NET.Serializer.Xmi/ISerializer.cs
@@ -44,10 +44,17 @@ public interface ISerializer
         /// <param name="includeDerivedProperties">
         /// Asserts that derived properties should also be part of the serialization
         /// </param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
-        void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream);
+        void Serialize(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream);
 
         /// <summary>
         /// Serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>,
@@ -59,6 +66,10 @@ public interface ISerializer
         /// <param name="includeDerivedProperties">
         /// Asserts that derived properties should also be part of the serialization
         /// </param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag. <c>true</c>: serialize all implied relationships with isImpliedIncluded=true.
+        /// <c>false</c>: exclude all implied relationships with isImpliedIncluded=false. <c>null</c>: per-element control.
+        /// </param>
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
@@ -68,7 +79,7 @@ public interface ISerializer
         /// <param name="currentFileUri">
         /// The optional <see cref="Uri"/> of the current output file for relative href computation
         /// </param>
-        void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+        void Serialize(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
 
         /// <summary>
         /// Asynchronously serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>
@@ -82,10 +93,14 @@ public interface ISerializer
         /// <param name="includeDerivedProperties">
         /// Asserts that derived properties should also be part of the serialization
         /// </param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag. <c>true</c>: serialize all implied relationships with isImpliedIncluded=true.
+        /// <c>false</c>: exclude all implied relationships with isImpliedIncluded=false. <c>null</c>: per-element control.
+        /// </param>
         /// <param name="cancellationToken">
         /// The <see cref="CancellationToken"/> used to cancel the operation
         /// </param>
-        Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, Stream stream, CancellationToken cancellationToken);
+        Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream, CancellationToken cancellationToken);
 
         /// <summary>
         /// Serialize an <see cref="INamespace"/> to multiple XMI files based on the element origin map
@@ -93,7 +108,13 @@ public interface ISerializer
         /// <param name="rootNamespace">The root <see cref="INamespace"/> containing all elements</param>
         /// <param name="elementOriginMap">The <see cref="IXmiElementOriginMap"/> tracking element-to-file associations</param>
         /// <param name="outputDirectory">The target directory for output files</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOriginMap, DirectoryInfo outputDirectory, bool includeDerivedProperties);
+        /// <param name="includeDerivedProperties">
+        /// Asserts that derived properties should also be part of the serialization
+        /// </param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag. <c>true</c>: serialize all implied relationships with isImpliedIncluded=true.
+        /// <c>false</c>: exclude all implied relationships with isImpliedIncluded=false. <c>null</c>: per-element control.
+        /// </param>
+        void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOriginMap, DirectoryInfo outputDirectory, bool includeDerivedProperties, bool includesImplied);
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Serializer.cs b/SysML2.NET.Serializer.Xmi/Serializer.cs
index 689a82a99..1bb92ff55 100644
--- a/SysML2.NET.Serializer.Xmi/Serializer.cs
+++ b/SysML2.NET.Serializer.Xmi/Serializer.cs
@@ -21,7 +21,6 @@
 namespace SysML2.NET.Serializer.Xmi
 {
     using System;
-    using System.Collections.Generic;
     using System.IO;
     using System.Linq;
     using System.Threading;
@@ -43,11 +42,15 @@ namespace SysML2.NET.Serializer.Xmi
     public class Serializer : ISerializer
     {
         private const string XmiNamespace = "http://www.omg.org/spec/XMI/20131001";
+        
         private const string XsiNamespace = "http://www.w3.org/2001/XMLSchema-instance";
+        
         private const string SysmlNamespace = "https://www.omg.org/spec/SysML/20240201";
 
         private readonly ILogger<Serializer> logger;
+        
         private readonly ILoggerFactory loggerFactory;
+        
         private readonly IXmiDataWriterFacade xmiWriterFacade;
 
         /// <summary>Initializes a new instance of the <see cref="Serializer"></see> class.</summary>
@@ -56,7 +59,7 @@ public Serializer(ILoggerFactory loggerFactory)
         {
             this.loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
             this.logger = this.loggerFactory.CreateLogger<Serializer>();
-            this.xmiWriterFacade = new XmiDataWriterFacade();
+            this.xmiWriterFacade = new XmiDataWriterFacade(this.loggerFactory);
         }
 
         /// <summary>
@@ -68,12 +71,19 @@ public Serializer(ILoggerFactory loggerFactory)
         /// <param name="includeDerivedProperties">
         /// Asserts that derived properties should also be part of the serialization
         /// </param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
-        public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream)
+        public void Serialize(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream)
         {
-            this.Serialize(@namespace, includeDerivedProperties, stream, null, null);
+            this.Serialize(@namespace, includeDerivedProperties,includesImplied, stream, null, null);
         }
 
         /// <summary>
@@ -86,6 +96,13 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stre
         /// <param name="includeDerivedProperties">
         /// Asserts that derived properties should also be part of the serialization
         /// </param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
@@ -95,7 +112,7 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stre
         /// <param name="currentFileUri">
         /// The optional <see cref="Uri"/> of the current output file for relative href computation
         /// </param>
-        public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stream stream, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        public void Serialize(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
         {
             if (@namespace == null)
             {
@@ -123,7 +140,7 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stre
 
             xmlWriter.WriteStartDocument();
 
-            this.WriteNamespaceElement(xmlWriter, @namespace, includeDerivedProperties, elementOriginMap, currentFileUri);
+            this.WriteNamespaceElement(xmlWriter, @namespace, includeDerivedProperties, elementOriginMap, currentFileUri, includesImplied);
 
             xmlWriter.WriteEndDocument();
             xmlWriter.Flush();
@@ -143,12 +160,22 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, Stre
         /// <param name="includeDerivedProperties">
         /// Asserts that derived properties should also be part of the serialization
         /// </param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="cancellationToken">
         /// The <see cref="CancellationToken"/> used to cancel the operation
         /// </param>
-        public Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, Stream stream, CancellationToken cancellationToken)
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag.
+        /// </param>
+        public Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream, CancellationToken cancellationToken)
         {
-            return Task.Run(() => this.Serialize(@namespace, includeDerivedProperties, stream), cancellationToken);
+            return Task.Run(() => this.Serialize(@namespace, includeDerivedProperties, includesImplied, stream), cancellationToken);
         }
 
         /// <summary>
@@ -157,8 +184,17 @@ public Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties,
         /// <param name="rootNamespace">The root <see cref="INamespace"/> containing all elements</param>
         /// <param name="elementOriginMap">The <see cref="IXmiElementOriginMap"/> tracking element-to-file associations</param>
         /// <param name="outputDirectory">The target directory for output files</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        public void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOriginMap, DirectoryInfo outputDirectory, bool includeDerivedProperties)
+        /// <param name="includeDerivedProperties">
+        /// Asserts that derived properties should also be part of the serialization
+        /// </param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
+        public void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOriginMap, DirectoryInfo outputDirectory, bool includeDerivedProperties, bool includesImplied)
         {
             if (rootNamespace == null)
             {
@@ -211,13 +247,13 @@ public void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOrig
                 }
 
                 using var fileStream = new FileStream(outputPath, FileMode.Create, FileAccess.Write);
-                this.Serialize(fileRootNamespace, includeDerivedProperties, fileStream, elementOriginMap, outputUri);
+                this.Serialize(fileRootNamespace, includeDerivedProperties, includesImplied, fileStream, elementOriginMap, outputUri);
             }
 
             this.logger.LogInformation("Multi-file XMI serialization completed");
         }
 
-        private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool includesImplied)
         {
             xmlWriter.WriteStartElement("sysml", "Namespace", SysmlNamespace);
             xmlWriter.WriteAttributeString("xmlns", "xmi", null, XmiNamespace);
@@ -245,7 +281,7 @@ private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, b
                 xmlWriter.WriteAttributeString("elementId", @namespace.ElementId);
             }
 
-            if (@namespace.IsImpliedIncluded)
+            if (includesImplied || @namespace.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -255,6 +291,11 @@ private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, b
             {
                 foreach (var relationship in @namespace.OwnedRelationship)
                 {
+                    if (!includesImplied && relationship is IRelationship { IsImplied: true })
+                    {
+                        continue;
+                    }
+
                     if (relationship is IData relationshipData)
                     {
                         if (elementOriginMap != null && currentFileUri != null)
@@ -273,7 +314,7 @@ private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, b
                             }
                         }
 
-                        this.xmiWriterFacade.Write(xmlWriter, relationshipData, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.xmiWriterFacade.Write(xmlWriter, relationshipData, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs
index 2c527debd..c540a16fc 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AcceptActionUsageWriter" /> is to write an instance of <see cref="IAcceptActionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class AcceptActionUsageWriter
+    public class AcceptActionUsageWriter : XmiDataWriter<IAcceptActionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AcceptActionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AcceptActionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AcceptActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AcceptActionUsageWriter>.Instance : loggerFactory.CreateLogger<AcceptActionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAcceptActionUsage" /> object to its XML representation
         /// </summary>
@@ -78,698 +99,2191 @@ public static class AcceptActionUsageWriter
         /// <param name="poco">The <see cref="IAcceptActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AcceptActionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadParameter, "payloadParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadParameter, "payloadParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.receiverArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAcceptActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAcceptActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AcceptActionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadParameter, "payloadParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.receiverArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs
index f589f5c7b..e8dbc9f01 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ActionDefinitionWriter" /> is to write an instance of <see cref="IActionDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class ActionDefinitionWriter
+    public class ActionDefinitionWriter : XmiDataWriter<IActionDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ActionDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ActionDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ActionDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ActionDefinitionWriter>.Instance : loggerFactory.CreateLogger<ActionDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IActionDefinition" /> object to its XML representation
         /// </summary>
@@ -74,559 +95,1719 @@ public static class ActionDefinitionWriter
         /// <param name="poco">The <see cref="IActionDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IActionDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ActionDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedSpecialization != null)
-                {
-                    foreach (var item in poco.ownedSpecialization)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IActionDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IActionDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ActionDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs
index 9e8f73cb7..3648d3414 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ActionUsageWriter" /> is to write an instance of <see cref="IActionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class ActionUsageWriter
+    public class ActionUsageWriter : XmiDataWriter<IActionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ActionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ActionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ActionUsageWriter>.Instance : loggerFactory.CreateLogger<ActionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IActionUsage" /> object to its XML representation
         /// </summary>
@@ -77,686 +98,2143 @@ public static class ActionUsageWriter
         /// <param name="poco">The <see cref="IActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ActionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ActionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs
index f729cd662..4372ce7b9 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ActorMembershipWriter" /> is to write an instance of <see cref="IActorMembership" />
     /// to the XMI document
     /// </summary>
-    public static class ActorMembershipWriter
+    public class ActorMembershipWriter : XmiDataWriter<IActorMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ActorMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ActorMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ActorMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ActorMembershipWriter>.Instance : loggerFactory.CreateLogger<ActorMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IActorMembership" /> object to its XML representation
         /// </summary>
@@ -54,160 +75,474 @@ public static class ActorMembershipWriter
         /// <param name="poco">The <see cref="IActorMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IActorMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IActorMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ActorMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedActorParameter != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedActorParameter, "ownedActorParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IActorMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IActorMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ActorMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedActorParameter != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedActorParameter, "ownedActorParameter", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedActorParameter, "ownedActorParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs
index 7ba296a0a..261ba58da 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AllocationDefinitionWriter" /> is to write an instance of <see cref="IAllocationDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class AllocationDefinitionWriter
+    public class AllocationDefinitionWriter : XmiDataWriter<IAllocationDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AllocationDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AllocationDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AllocationDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AllocationDefinitionWriter>.Instance : loggerFactory.CreateLogger<AllocationDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAllocationDefinition" /> object to its XML representation
         /// </summary>
@@ -74,585 +95,1793 @@ public static class AllocationDefinitionWriter
         /// <param name="poco">The <see cref="IAllocationDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAllocationDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AllocationDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.allocation != null)
                 {
                     foreach (var item in poco.allocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "allocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "allocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectionEnd != null)
                 {
                     foreach (var item in poco.connectionEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectionEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectionEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedRendering != null)
-                {
-                    foreach (var item in poco.ownedRendering)
-                    {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAllocationDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAllocationDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AllocationDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.allocation != null)
+                {
+                    foreach (var item in poco.allocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "allocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectionEnd != null)
+                {
+                    foreach (var item in poco.connectionEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectionEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs
index d3d7c8bcc..befe836ee 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -70,8 +74,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AllocationUsageWriter" /> is to write an instance of <see cref="IAllocationUsage" />
     /// to the XMI document
     /// </summary>
-    public static class AllocationUsageWriter
+    public class AllocationUsageWriter : XmiDataWriter<IAllocationUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AllocationUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AllocationUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AllocationUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AllocationUsageWriter>.Instance : loggerFactory.CreateLogger<AllocationUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAllocationUsage" /> object to its XML representation
         /// </summary>
@@ -79,737 +100,2299 @@ public static class AllocationUsageWriter
         /// <param name="poco">The <see cref="IAllocationUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAllocationUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AllocationUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.allocationDefinition != null)
                 {
                     foreach (var item in poco.allocationDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "allocationDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "allocationDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedReference != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.partDefinition != null)
                 {
                     foreach (var item in poco.partDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAllocationUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAllocationUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AllocationUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.allocationDefinition != null)
+                {
+                    foreach (var item in poco.allocationDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "allocationDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.partDefinition != null)
+                {
+                    foreach (var item in poco.partDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs
index 4a31e2e09..0f194cf4d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AnalysisCaseDefinitionWriter" /> is to write an instance of <see cref="IAnalysisCaseDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class AnalysisCaseDefinitionWriter
+    public class AnalysisCaseDefinitionWriter : XmiDataWriter<IAnalysisCaseDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AnalysisCaseDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AnalysisCaseDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AnalysisCaseDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AnalysisCaseDefinitionWriter>.Instance : loggerFactory.CreateLogger<AnalysisCaseDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAnalysisCaseDefinition" /> object to its XML representation
         /// </summary>
@@ -75,600 +96,1865 @@ public static class AnalysisCaseDefinitionWriter
         /// <param name="poco">The <see cref="IAnalysisCaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AnalysisCaseDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
-            if (poco.IsVariation)
-            {
-                xmlWriter.WriteAttributeString("isVariation", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.calculation != null)
                 {
                     foreach (var item in poco.calculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.objectiveRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedPart != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.resultExpression != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAnalysisCaseDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAnalysisCaseDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AnalysisCaseDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.calculation != null)
+                {
+                    foreach (var item in poco.calculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.objectiveRequirement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.resultExpression != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs
index 5d3857349..b87ee7283 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AnalysisCaseUsageWriter" /> is to write an instance of <see cref="IAnalysisCaseUsage" />
     /// to the XMI document
     /// </summary>
-    public static class AnalysisCaseUsageWriter
+    public class AnalysisCaseUsageWriter : XmiDataWriter<IAnalysisCaseUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AnalysisCaseUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AnalysisCaseUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AnalysisCaseUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AnalysisCaseUsageWriter>.Instance : loggerFactory.CreateLogger<AnalysisCaseUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAnalysisCaseUsage" /> object to its XML representation
         /// </summary>
@@ -78,717 +99,2261 @@ public static class AnalysisCaseUsageWriter
         /// <param name="poco">The <see cref="IAnalysisCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AnalysisCaseUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.analysisCaseDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.analysisCaseDefinition, "analysisCaseDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.analysisCaseDefinition, "analysisCaseDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedReference != null)
-                {
-                    foreach (var item in poco.nestedReference)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.objectiveRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.resultExpression != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAnalysisCaseUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAnalysisCaseUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AnalysisCaseUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.analysisCaseDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.analysisCaseDefinition, "analysisCaseDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.objectiveRequirement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.resultExpression != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs
index 00453e86e..8b5a1c68d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
@@ -39,8 +43,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AnnotatingElementWriter" /> is to write an instance of <see cref="IAnnotatingElement" />
     /// to the XMI document
     /// </summary>
-    public static class AnnotatingElementWriter
+    public class AnnotatingElementWriter : XmiDataWriter<IAnnotatingElement>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AnnotatingElementWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AnnotatingElementWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AnnotatingElementWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AnnotatingElementWriter>.Instance : loggerFactory.CreateLogger<AnnotatingElementWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAnnotatingElement" /> object to its XML representation
         /// </summary>
@@ -48,142 +69,414 @@ public static class AnnotatingElementWriter
         /// <param name="poco">The <see cref="IAnnotatingElement" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AnnotatingElement");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.annotatedElement != null)
+                {
+                    foreach (var item in poco.annotatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAnnotatingElement" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAnnotatingElement" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotatingElement poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AnnotatingElement");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningAnnotatingRelationship != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs
index 290679907..194d2ef71 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
@@ -39,8 +43,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AnnotationWriter" /> is to write an instance of <see cref="IAnnotation" />
     /// to the XMI document
     /// </summary>
-    public static class AnnotationWriter
+    public class AnnotationWriter : XmiDataWriter<IAnnotation>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AnnotationWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AnnotationWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AnnotationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AnnotationWriter>.Instance : loggerFactory.CreateLogger<AnnotationWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAnnotation" /> object to its XML representation
         /// </summary>
@@ -48,159 +69,464 @@ public static class AnnotationWriter
         /// <param name="poco">The <see cref="IAnnotation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAnnotation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAnnotation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Annotation");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.AnnotatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.AnnotatedElement, "annotatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.AnnotatedElement, "annotatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.annotatingElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.annotatingElement, "annotatingElement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotatingElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedAnnotatingElement, "ownedAnnotatingElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningAnnotatedElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatedElement, "owningAnnotatedElement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningAnnotatingElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingElement, "owningAnnotatingElement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAnnotation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAnnotation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Annotation");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (poco.AnnotatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.AnnotatedElement, "annotatedElement", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
                 if (poco.annotatingElement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.annotatingElement, "annotatingElement", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.annotatingElement, "annotatingElement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotatingElement != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedAnnotatingElement, "ownedAnnotatingElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedAnnotatingElement, "ownedAnnotatingElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningAnnotatedElement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatedElement, "owningAnnotatedElement", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatedElement, "owningAnnotatedElement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningAnnotatingElement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingElement, "owningAnnotatingElement", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingElement, "owningAnnotatingElement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs
index 50727dd58..fb100b14d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AssertConstraintUsageWriter" /> is to write an instance of <see cref="IAssertConstraintUsage" />
     /// to the XMI document
     /// </summary>
-    public static class AssertConstraintUsageWriter
+    public class AssertConstraintUsageWriter : XmiDataWriter<IAssertConstraintUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AssertConstraintUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AssertConstraintUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AssertConstraintUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AssertConstraintUsageWriter>.Instance : loggerFactory.CreateLogger<AssertConstraintUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAssertConstraintUsage" /> object to its XML representation
         /// </summary>
@@ -78,699 +99,2195 @@ public static class AssertConstraintUsageWriter
         /// <param name="poco">The <see cref="IAssertConstraintUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AssertConstraintUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsNegated)
             {
                 xmlWriter.WriteAttributeString("isNegated", "true");
             }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (poco.assertedConstraint != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.assertedConstraint, "assertedConstraint", elementOriginMap, currentFileUri);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
-                if (poco.assertedConstraint != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.assertedConstraint, "assertedConstraint", elementOriginMap, currentFileUri);
-                }
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.constraintDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAssertConstraintUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAssertConstraintUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AssertConstraintUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsNegated)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isNegated", null, "true");
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.assertedConstraint != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.assertedConstraint, "assertedConstraint", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.constraintDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs
index 226d6ff12..d12f91d13 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AssignmentActionUsageWriter" /> is to write an instance of <see cref="IAssignmentActionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class AssignmentActionUsageWriter
+    public class AssignmentActionUsageWriter : XmiDataWriter<IAssignmentActionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AssignmentActionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AssignmentActionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AssignmentActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AssignmentActionUsageWriter>.Instance : loggerFactory.CreateLogger<AssignmentActionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAssignmentActionUsage" /> object to its XML representation
         /// </summary>
@@ -78,698 +99,2191 @@ public static class AssignmentActionUsageWriter
         /// <param name="poco">The <see cref="IAssignmentActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AssignmentActionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.referent != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetArgument, "targetArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetArgument, "targetArgument", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.valueExpression != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.valueExpression, "valueExpression", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.valueExpression, "valueExpression", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAssignmentActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAssignmentActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AssignmentActionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.referent != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetArgument, "targetArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.valueExpression != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.valueExpression, "valueExpression", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs
index b2c1a9bf0..3eb03121a 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AssociationStructureWriter" /> is to write an instance of <see cref="IAssociationStructure" />
     /// to the XMI document
     /// </summary>
-    public static class AssociationStructureWriter
+    public class AssociationStructureWriter : XmiDataWriter<IAssociationStructure>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AssociationStructureWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AssociationStructureWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AssociationStructureWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AssociationStructureWriter>.Instance : loggerFactory.CreateLogger<AssociationStructureWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAssociationStructure" /> object to its XML representation
         /// </summary>
@@ -53,353 +74,1069 @@ public static class AssociationStructureWriter
         /// <param name="poco">The <see cref="IAssociationStructure" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAssociationStructure poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AssociationStructure");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.associationEnd != null)
                 {
                     foreach (var item in poco.associationEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAssociationStructure" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAssociationStructure" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AssociationStructure");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.associationEnd != null)
+                {
+                    foreach (var item in poco.associationEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs
index 8dfadb206..ff7908ce1 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AssociationWriter" /> is to write an instance of <see cref="IAssociation" />
     /// to the XMI document
     /// </summary>
-    public static class AssociationWriter
+    public class AssociationWriter : XmiDataWriter<IAssociation>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AssociationWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AssociationWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AssociationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AssociationWriter>.Instance : loggerFactory.CreateLogger<AssociationWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAssociation" /> object to its XML representation
         /// </summary>
@@ -52,353 +73,1069 @@ public static class AssociationWriter
         /// <param name="poco">The <see cref="IAssociation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAssociation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAssociation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Association");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.associationEnd != null)
                 {
                     foreach (var item in poco.associationEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAssociation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAssociation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Association");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.associationEnd != null)
+                {
+                    foreach (var item in poco.associationEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs
index 9439df2cb..d168f5cc9 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AttributeDefinitionWriter" /> is to write an instance of <see cref="IAttributeDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class AttributeDefinitionWriter
+    public class AttributeDefinitionWriter : XmiDataWriter<IAttributeDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AttributeDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AttributeDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AttributeDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AttributeDefinitionWriter>.Instance : loggerFactory.CreateLogger<AttributeDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAttributeDefinition" /> object to its XML representation
         /// </summary>
@@ -74,541 +95,1665 @@ public static class AttributeDefinitionWriter
         /// <param name="poco">The <see cref="IAttributeDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAttributeDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AttributeDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAttributeDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAttributeDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AttributeDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs
index 3ec3e9556..8f3021b2e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="AttributeUsageWriter" /> is to write an instance of <see cref="IAttributeUsage" />
     /// to the XMI document
     /// </summary>
-    public static class AttributeUsageWriter
+    public class AttributeUsageWriter : XmiDataWriter<IAttributeUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<AttributeUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AttributeUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public AttributeUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<AttributeUsageWriter>.Instance : loggerFactory.CreateLogger<AttributeUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IAttributeUsage" /> object to its XML representation
         /// </summary>
@@ -75,670 +96,2091 @@ public static class AttributeUsageWriter
         /// <param name="poco">The <see cref="IAttributeUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IAttributeUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AttributeUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.attributeDefinition != null)
                 {
                     foreach (var item in poco.attributeDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "attributeDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "attributeDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUseCase != null)
-                {
-                    foreach (var item in poco.nestedUseCase)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IAttributeUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IAttributeUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AttributeUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.attributeDefinition != null)
+                {
+                    foreach (var item in poco.attributeDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "attributeDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs
index fc52a5ef0..c87c9cb8b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="BehaviorWriter" /> is to write an instance of <see cref="IBehavior" />
     /// to the XMI document
     /// </summary>
-    public static class BehaviorWriter
+    public class BehaviorWriter : XmiDataWriter<IBehavior>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<BehaviorWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BehaviorWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public BehaviorWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<BehaviorWriter>.Instance : loggerFactory.CreateLogger<BehaviorWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IBehavior" /> object to its XML representation
         /// </summary>
@@ -53,327 +74,995 @@ public static class BehaviorWriter
         /// <param name="poco">The <see cref="IBehavior" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IBehavior poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Behavior");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
-            {
-                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
-            }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
                     xmlWriter.WriteAttributeString("isConjugated", "true");
                 }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IBehavior" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IBehavior" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IBehavior poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Behavior");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs
index 04c26f13f..d0dae240c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -67,8 +71,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="BindingConnectorAsUsageWriter" /> is to write an instance of <see cref="IBindingConnectorAsUsage" />
     /// to the XMI document
     /// </summary>
-    public static class BindingConnectorAsUsageWriter
+    public class BindingConnectorAsUsageWriter : XmiDataWriter<IBindingConnectorAsUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<BindingConnectorAsUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BindingConnectorAsUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public BindingConnectorAsUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<BindingConnectorAsUsageWriter>.Instance : loggerFactory.CreateLogger<BindingConnectorAsUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IBindingConnectorAsUsage" /> object to its XML representation
         /// </summary>
@@ -76,714 +97,2225 @@ public static class BindingConnectorAsUsageWriter
         /// <param name="poco">The <see cref="IBindingConnectorAsUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:BindingConnectorAsUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.association != null)
                 {
                     foreach (var item in poco.association)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.definition != null)
                 {
                     foreach (var item in poco.definition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedRequirement != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IBindingConnectorAsUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IBindingConnectorAsUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:BindingConnectorAsUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.association != null)
+                {
+                    foreach (var item in poco.association)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.definition != null)
+                {
+                    foreach (var item in poco.definition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs
index ac7adda90..336dbe87e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="BindingConnectorWriter" /> is to write an instance of <see cref="IBindingConnector" />
     /// to the XMI document
     /// </summary>
-    public static class BindingConnectorWriter
+    public class BindingConnectorWriter : XmiDataWriter<IBindingConnector>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<BindingConnectorWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BindingConnectorWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public BindingConnectorWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<BindingConnectorWriter>.Instance : loggerFactory.CreateLogger<BindingConnectorWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IBindingConnector" /> object to its XML representation
         /// </summary>
@@ -53,474 +74,1457 @@ public static class BindingConnectorWriter
         /// <param name="poco">The <see cref="IBindingConnector" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IBindingConnector poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:BindingConnector");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.association != null)
                 {
                     foreach (var item in poco.association)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedTyping != null)
-                {
-                    foreach (var item in poco.ownedTyping)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IBindingConnector" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IBindingConnector" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:BindingConnector");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.association != null)
+                {
+                    foreach (var item in poco.association)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs
index 1452894a2..b810da3b5 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="BooleanExpressionWriter" /> is to write an instance of <see cref="IBooleanExpression" />
     /// to the XMI document
     /// </summary>
-    public static class BooleanExpressionWriter
+    public class BooleanExpressionWriter : XmiDataWriter<IBooleanExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<BooleanExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BooleanExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public BooleanExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<BooleanExpressionWriter>.Instance : loggerFactory.CreateLogger<BooleanExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IBooleanExpression" /> object to its XML representation
         /// </summary>
@@ -53,449 +74,1393 @@ public static class BooleanExpressionWriter
         /// <param name="poco">The <see cref="IBooleanExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IBooleanExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:BooleanExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.predicate != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IBooleanExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IBooleanExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:BooleanExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.predicate != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs
index 5d060e0e1..8acd43de0 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="CalculationDefinitionWriter" /> is to write an instance of <see cref="ICalculationDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class CalculationDefinitionWriter
+    public class CalculationDefinitionWriter : XmiDataWriter<ICalculationDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<CalculationDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CalculationDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public CalculationDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<CalculationDefinitionWriter>.Instance : loggerFactory.CreateLogger<CalculationDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ICalculationDefinition" /> object to its XML representation
         /// </summary>
@@ -75,581 +96,1795 @@ public static class CalculationDefinitionWriter
         /// <param name="poco">The <see cref="ICalculationDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ICalculationDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CalculationDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
-            if (poco.IsVariation)
-            {
-                xmlWriter.WriteAttributeString("isVariation", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.calculation != null)
                 {
                     foreach (var item in poco.calculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedReference != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ICalculationDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICalculationDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CalculationDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.calculation != null)
+                {
+                    foreach (var item in poco.calculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs
index dbe6e2d82..3f06c0251 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="CalculationUsageWriter" /> is to write an instance of <see cref="ICalculationUsage" />
     /// to the XMI document
     /// </summary>
-    public static class CalculationUsageWriter
+    public class CalculationUsageWriter : XmiDataWriter<ICalculationUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<CalculationUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CalculationUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public CalculationUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<CalculationUsageWriter>.Instance : loggerFactory.CreateLogger<CalculationUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ICalculationUsage" /> object to its XML representation
         /// </summary>
@@ -78,698 +99,2191 @@ public static class CalculationUsageWriter
         /// <param name="poco">The <see cref="ICalculationUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ICalculationUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CalculationUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.calculationDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.calculationDefinition, "calculationDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.calculationDefinition, "calculationDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedRendering != null)
-                {
-                    foreach (var item in poco.nestedRendering)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ICalculationUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICalculationUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CalculationUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.calculationDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.calculationDefinition, "calculationDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs
index a671aedd9..567904778 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="CaseDefinitionWriter" /> is to write an instance of <see cref="ICaseDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class CaseDefinitionWriter
+    public class CaseDefinitionWriter : XmiDataWriter<ICaseDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<CaseDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CaseDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public CaseDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<CaseDefinitionWriter>.Instance : loggerFactory.CreateLogger<CaseDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ICaseDefinition" /> object to its XML representation
         /// </summary>
@@ -75,596 +96,1849 @@ public static class CaseDefinitionWriter
         /// <param name="poco">The <see cref="ICaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ICaseDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CaseDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
-            if (poco.IsVariation)
-            {
-                xmlWriter.WriteAttributeString("isVariation", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.calculation != null)
                 {
                     foreach (var item in poco.calculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.objectiveRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedPart != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ICaseDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICaseDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CaseDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.calculation != null)
+                {
+                    foreach (var item in poco.calculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.objectiveRequirement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs
index af56d53eb..ab6187521 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="CaseUsageWriter" /> is to write an instance of <see cref="ICaseUsage" />
     /// to the XMI document
     /// </summary>
-    public static class CaseUsageWriter
+    public class CaseUsageWriter : XmiDataWriter<ICaseUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<CaseUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CaseUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public CaseUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<CaseUsageWriter>.Instance : loggerFactory.CreateLogger<CaseUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ICaseUsage" /> object to its XML representation
         /// </summary>
@@ -78,713 +99,2245 @@ public static class CaseUsageWriter
         /// <param name="poco">The <see cref="ICaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CaseUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.caseDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedReference != null)
-                {
-                    foreach (var item in poco.nestedReference)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.objectiveRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ICaseUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICaseUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CaseUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.caseDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.objectiveRequirement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs
index 4df80763e..b5a1e2d54 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ClassWriter" /> is to write an instance of <see cref="IClass" />
     /// to the XMI document
     /// </summary>
-    public static class ClassWriter
+    public class ClassWriter : XmiDataWriter<IClass>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ClassWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClassWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ClassWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ClassWriter>.Instance : loggerFactory.CreateLogger<ClassWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IClass" /> object to its XML representation
         /// </summary>
@@ -52,320 +73,973 @@ public static class ClassWriter
         /// <param name="poco">The <see cref="IClass" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IClass poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IClass poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Class");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
-            {
-                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
-            }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
                     xmlWriter.WriteAttributeString("isConjugated", "true");
                 }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IClass" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IClass" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IClass poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Class");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs
index 8214dcbb8..1c7e04d04 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -42,8 +46,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ClassifierWriter" /> is to write an instance of <see cref="IClassifier" />
     /// to the XMI document
     /// </summary>
-    public static class ClassifierWriter
+    public class ClassifierWriter : XmiDataWriter<IClassifier>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ClassifierWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClassifierWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ClassifierWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ClassifierWriter>.Instance : loggerFactory.CreateLogger<ClassifierWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IClassifier" /> object to its XML representation
         /// </summary>
@@ -51,320 +72,973 @@ public static class ClassifierWriter
         /// <param name="poco">The <see cref="IClassifier" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IClassifier poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IClassifier poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Classifier");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
-            {
-                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
-            }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
                     xmlWriter.WriteAttributeString("isConjugated", "true");
                 }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IClassifier" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IClassifier" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IClassifier poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Classifier");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs
index a555c9e08..6185bd188 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="CollectExpressionWriter" /> is to write an instance of <see cref="ICollectExpression" />
     /// to the XMI document
     /// </summary>
-    public static class CollectExpressionWriter
+    public class CollectExpressionWriter : XmiDataWriter<ICollectExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<CollectExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CollectExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public CollectExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<CollectExpressionWriter>.Instance : loggerFactory.CreateLogger<CollectExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ICollectExpression" /> object to its XML representation
         /// </summary>
@@ -54,464 +75,1441 @@ public static class CollectExpressionWriter
         /// <param name="poco">The <see cref="ICollectExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ICollectExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CollectExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
-            {
-                xmlWriter.WriteAttributeString("operator", poco.Operator);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                xmlWriter.WriteAttributeString("operator", poco.Operator);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.instantiatedType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedTypeFeaturing != null)
-                {
-                    foreach (var item in poco.ownedTypeFeaturing)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ICollectExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICollectExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CollectExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.instantiatedType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs
index 5244eb67d..e180af501 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
@@ -39,8 +43,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="CommentWriter" /> is to write an instance of <see cref="IComment" />
     /// to the XMI document
     /// </summary>
-    public static class CommentWriter
+    public class CommentWriter : XmiDataWriter<IComment>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<CommentWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommentWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public CommentWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<CommentWriter>.Instance : loggerFactory.CreateLogger<CommentWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IComment" /> object to its XML representation
         /// </summary>
@@ -48,150 +69,434 @@ public static class CommentWriter
         /// <param name="poco">The <see cref="IComment" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IComment poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IComment poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Comment");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.Body))
             {
                 xmlWriter.WriteAttributeString("body", poco.Body);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            if (!string.IsNullOrWhiteSpace(poco.Locale))
-            {
-                xmlWriter.WriteAttributeString("locale", poco.Locale);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Locale))
+            {
+                xmlWriter.WriteAttributeString("locale", poco.Locale);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.annotatedElement != null)
+                {
+                    foreach (var item in poco.annotatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IComment" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IComment" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IComment poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Comment");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Body))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "body", null, poco.Body);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Locale))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "locale", null, poco.Locale);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningAnnotatingRelationship != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs
index 0515c36e4..520990734 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConcernDefinitionWriter" /> is to write an instance of <see cref="IConcernDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class ConcernDefinitionWriter
+    public class ConcernDefinitionWriter : XmiDataWriter<IConcernDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConcernDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConcernDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConcernDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConcernDefinitionWriter>.Instance : loggerFactory.CreateLogger<ConcernDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConcernDefinition" /> object to its XML representation
         /// </summary>
@@ -75,610 +96,1893 @@ public static class ConcernDefinitionWriter
         /// <param name="poco">The <see cref="IConcernDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConcernDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConcernDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
-            if (poco.IsVariation)
-            {
-                xmlWriter.WriteAttributeString("isVariation", "true");
-            }
-            if (!string.IsNullOrWhiteSpace(poco.ReqId))
-            {
-                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
-                if (poco.text != null && poco.text.Count > 0)
-                {
-                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (poco.text != null && poco.text.Count > 0)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedMetadata != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConcernDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConcernDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConcernDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "text", null, string.Join(" ", poco.text));
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs
index 154e035ee..a941e3afd 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConcernUsageWriter" /> is to write an instance of <see cref="IConcernUsage" />
     /// to the XMI document
     /// </summary>
-    public static class ConcernUsageWriter
+    public class ConcernUsageWriter : XmiDataWriter<IConcernUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConcernUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConcernUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConcernUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConcernUsageWriter>.Instance : loggerFactory.CreateLogger<ConcernUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConcernUsage" /> object to its XML representation
         /// </summary>
@@ -78,734 +99,2311 @@ public static class ConcernUsageWriter
         /// <param name="poco">The <see cref="IConcernUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConcernUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConcernUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
-            if (!string.IsNullOrWhiteSpace(poco.ReqId))
-            {
-                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
-                if (poco.text != null && poco.text.Count > 0)
-                {
-                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (poco.text != null && poco.text.Count > 0)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.concernDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.concernDefinition, "concernDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.concernDefinition, "concernDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedMetadata != null)
-                {
-                    foreach (var item in poco.nestedMetadata)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConcernUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConcernUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConcernUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "text", null, string.Join(" ", poco.text));
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.concernDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.concernDefinition, "concernDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs
index b252912cf..6b249d205 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -64,8 +68,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConjugatedPortDefinitionWriter" /> is to write an instance of <see cref="IConjugatedPortDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class ConjugatedPortDefinitionWriter
+    public class ConjugatedPortDefinitionWriter : XmiDataWriter<IConjugatedPortDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConjugatedPortDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConjugatedPortDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConjugatedPortDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConjugatedPortDefinitionWriter>.Instance : loggerFactory.CreateLogger<ConjugatedPortDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConjugatedPortDefinition" /> object to its XML representation
         /// </summary>
@@ -73,549 +94,1691 @@ public static class ConjugatedPortDefinitionWriter
         /// <param name="poco">The <see cref="IConjugatedPortDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConjugatedPortDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (poco.conjugatedPortDefinition != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
-                if (poco.conjugatedPortDefinition != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
-                }
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.originalPortDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.originalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.originalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPortConjugator != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ownedPortConjugator, "ownedPortConjugator", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ownedPortConjugator, "ownedPortConjugator", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedRequirement != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConjugatedPortDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConjugatedPortDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConjugatedPortDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.conjugatedPortDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.originalPortDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.originalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPortConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ownedPortConjugator, "ownedPortConjugator", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs
index 2a81d9c05..fa74fe71b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -42,8 +46,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConjugatedPortTypingWriter" /> is to write an instance of <see cref="IConjugatedPortTyping" />
     /// to the XMI document
     /// </summary>
-    public static class ConjugatedPortTypingWriter
+    public class ConjugatedPortTypingWriter : XmiDataWriter<IConjugatedPortTyping>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConjugatedPortTypingWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConjugatedPortTypingWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConjugatedPortTypingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConjugatedPortTypingWriter>.Instance : loggerFactory.CreateLogger<ConjugatedPortTypingWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConjugatedPortTyping" /> object to its XML representation
         /// </summary>
@@ -51,155 +72,442 @@ public static class ConjugatedPortTypingWriter
         /// <param name="poco">The <see cref="IConjugatedPortTyping" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConjugatedPortTyping");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.ConjugatedPortDefinition != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeature != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.portDefinition != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.portDefinition, "portDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.TypedFeature != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConjugatedPortTyping" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConjugatedPortTyping" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConjugatedPortTyping");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (poco.ConjugatedPortDefinition != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ConjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.portDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.portDefinition, "portDefinition", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.portDefinition, "portDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+            if (poco.TypedFeature != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs
index 12d427ca5..4f70a33b2 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConjugationWriter" /> is to write an instance of <see cref="IConjugation" />
     /// to the XMI document
     /// </summary>
-    public static class ConjugationWriter
+    public class ConjugationWriter : XmiDataWriter<IConjugation>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConjugationWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConjugationWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConjugationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConjugationWriter>.Instance : loggerFactory.CreateLogger<ConjugationWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConjugation" /> object to its XML representation
         /// </summary>
@@ -49,151 +70,426 @@ public static class ConjugationWriter
         /// <param name="poco">The <see cref="IConjugation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConjugation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConjugation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Conjugation");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.ConjugatedType != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OriginalType != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OriginalType, "originalType", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OriginalType, "originalType", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConjugation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConjugation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Conjugation");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (poco.ConjugatedType != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OriginalType != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OriginalType, "originalType", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs
index 46d88fa24..ca0365011 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConnectionDefinitionWriter" /> is to write an instance of <see cref="IConnectionDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class ConnectionDefinitionWriter
+    public class ConnectionDefinitionWriter : XmiDataWriter<IConnectionDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConnectionDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConnectionDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConnectionDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConnectionDefinitionWriter>.Instance : loggerFactory.CreateLogger<ConnectionDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConnectionDefinition" /> object to its XML representation
         /// </summary>
@@ -74,578 +95,1771 @@ public static class ConnectionDefinitionWriter
         /// <param name="poco">The <see cref="IConnectionDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConnectionDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConnectionDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.connectionEnd != null)
                 {
                     foreach (var item in poco.connectionEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectionEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectionEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedRendering != null)
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
                 {
-                    foreach (var item in poco.ownedRendering)
-                    {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConnectionDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConnectionDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConnectionDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.connectionEnd != null)
+                {
+                    foreach (var item in poco.connectionEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectionEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs
index 2bdc532f9..d2d5989d6 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -70,8 +74,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConnectionUsageWriter" /> is to write an instance of <see cref="IConnectionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class ConnectionUsageWriter
+    public class ConnectionUsageWriter : XmiDataWriter<IConnectionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConnectionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConnectionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConnectionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConnectionUsageWriter>.Instance : loggerFactory.CreateLogger<ConnectionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConnectionUsage" /> object to its XML representation
         /// </summary>
@@ -79,737 +100,2299 @@ public static class ConnectionUsageWriter
         /// <param name="poco">The <see cref="IConnectionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConnectionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConnectionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectionDefinition != null)
                 {
                     foreach (var item in poco.connectionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedReference != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.partDefinition != null)
                 {
                     foreach (var item in poco.partDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConnectionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConnectionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConnectionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectionDefinition != null)
+                {
+                    foreach (var item in poco.connectionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.partDefinition != null)
+                {
+                    foreach (var item in poco.partDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs
index 1db4cdd47..242a7d9ff 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConnectorWriter" /> is to write an instance of <see cref="IConnector" />
     /// to the XMI document
     /// </summary>
-    public static class ConnectorWriter
+    public class ConnectorWriter : XmiDataWriter<IConnector>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConnectorWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConnectorWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConnectorWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConnectorWriter>.Instance : loggerFactory.CreateLogger<ConnectorWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConnector" /> object to its XML representation
         /// </summary>
@@ -53,474 +74,1457 @@ public static class ConnectorWriter
         /// <param name="poco">The <see cref="IConnector" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConnector poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConnector poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Connector");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.association != null)
                 {
                     foreach (var item in poco.association)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedTyping != null)
-                {
-                    foreach (var item in poco.ownedTyping)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConnector" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConnector" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Connector");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.association != null)
+                {
+                    foreach (var item in poco.association)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs
index 6224eaa14..7d2e2f6e2 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConstraintDefinitionWriter" /> is to write an instance of <see cref="IConstraintDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class ConstraintDefinitionWriter
+    public class ConstraintDefinitionWriter : XmiDataWriter<IConstraintDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConstraintDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConstraintDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConstraintDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConstraintDefinitionWriter>.Instance : loggerFactory.CreateLogger<ConstraintDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConstraintDefinition" /> object to its XML representation
         /// </summary>
@@ -75,567 +96,1751 @@ public static class ConstraintDefinitionWriter
         /// <param name="poco">The <see cref="IConstraintDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConstraintDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConstraintDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
-            if (poco.IsVariation)
-            {
-                xmlWriter.WriteAttributeString("isVariation", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedRendering != null)
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConstraintDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConstraintDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConstraintDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs
index 8d6f3c985..93b6038b7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConstraintUsageWriter" /> is to write an instance of <see cref="IConstraintUsage" />
     /// to the XMI document
     /// </summary>
-    public static class ConstraintUsageWriter
+    public class ConstraintUsageWriter : XmiDataWriter<IConstraintUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConstraintUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConstraintUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConstraintUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConstraintUsageWriter>.Instance : loggerFactory.CreateLogger<ConstraintUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConstraintUsage" /> object to its XML representation
         /// </summary>
@@ -78,691 +99,2169 @@ public static class ConstraintUsageWriter
         /// <param name="poco">The <see cref="IConstraintUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConstraintUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConstraintUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.constraintDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedRequirement != null)
-                {
-                    foreach (var item in poco.nestedRequirement)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConstraintUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConstraintUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConstraintUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.constraintDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs
index 4a39a5e6e..df033e4bc 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ConstructorExpressionWriter" /> is to write an instance of <see cref="IConstructorExpression" />
     /// to the XMI document
     /// </summary>
-    public static class ConstructorExpressionWriter
+    public class ConstructorExpressionWriter : XmiDataWriter<IConstructorExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ConstructorExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConstructorExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ConstructorExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ConstructorExpressionWriter>.Instance : loggerFactory.CreateLogger<ConstructorExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IConstructorExpression" /> object to its XML representation
         /// </summary>
@@ -54,460 +75,1431 @@ public static class ConstructorExpressionWriter
         /// <param name="poco">The <see cref="IConstructorExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IConstructorExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConstructorExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.instantiatedType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IConstructorExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IConstructorExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConstructorExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.instantiatedType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs
index bcff68f7d..4b4393ca4 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="CrossSubsettingWriter" /> is to write an instance of <see cref="ICrossSubsetting" />
     /// to the XMI document
     /// </summary>
-    public static class CrossSubsettingWriter
+    public class CrossSubsettingWriter : XmiDataWriter<ICrossSubsetting>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<CrossSubsettingWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CrossSubsettingWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public CrossSubsettingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<CrossSubsettingWriter>.Instance : loggerFactory.CreateLogger<CrossSubsettingWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ICrossSubsetting" /> object to its XML representation
         /// </summary>
@@ -50,147 +71,416 @@ public static class CrossSubsettingWriter
         /// <param name="poco">The <see cref="ICrossSubsetting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CrossSubsetting");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.CrossedFeature != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.CrossedFeature, "crossedFeature", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.CrossedFeature, "crossedFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossingFeature != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossingFeature, "crossingFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ICrossSubsetting" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ICrossSubsetting" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CrossSubsetting");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (poco.CrossedFeature != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.CrossedFeature, "crossedFeature", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
                 if (poco.crossingFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossingFeature, "crossingFeature", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossingFeature, "crossingFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs
index 69d6e4146..6dfd50678 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="DataTypeWriter" /> is to write an instance of <see cref="IDataType" />
     /// to the XMI document
     /// </summary>
-    public static class DataTypeWriter
+    public class DataTypeWriter : XmiDataWriter<IDataType>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<DataTypeWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DataTypeWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public DataTypeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<DataTypeWriter>.Instance : loggerFactory.CreateLogger<DataTypeWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IDataType" /> object to its XML representation
         /// </summary>
@@ -52,320 +73,973 @@ public static class DataTypeWriter
         /// <param name="poco">The <see cref="IDataType" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IDataType poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDataType poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:DataType");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
-            {
-                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
-            }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
                     xmlWriter.WriteAttributeString("isConjugated", "true");
                 }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IDataType" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDataType" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDataType poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:DataType");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs
index 5b980db8b..c28d4a215 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="DecisionNodeWriter" /> is to write an instance of <see cref="IDecisionNode" />
     /// to the XMI document
     /// </summary>
-    public static class DecisionNodeWriter
+    public class DecisionNodeWriter : XmiDataWriter<IDecisionNode>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<DecisionNodeWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DecisionNodeWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public DecisionNodeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<DecisionNodeWriter>.Instance : loggerFactory.CreateLogger<DecisionNodeWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IDecisionNode" /> object to its XML representation
         /// </summary>
@@ -77,686 +98,2143 @@ public static class DecisionNodeWriter
         /// <param name="poco">The <see cref="IDecisionNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IDecisionNode poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:DecisionNode");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IDecisionNode" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDecisionNode" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:DecisionNode");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs
index 71002c545..9a2ad17b7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -64,8 +68,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="DefinitionWriter" /> is to write an instance of <see cref="IDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class DefinitionWriter
+    public class DefinitionWriter : XmiDataWriter<IDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<DefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public DefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<DefinitionWriter>.Instance : loggerFactory.CreateLogger<DefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IDefinition" /> object to its XML representation
         /// </summary>
@@ -73,541 +94,1665 @@ public static class DefinitionWriter
         /// <param name="poco">The <see cref="IDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Definition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Definition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs
index c18d81ba9..accd6045d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="DependencyWriter" /> is to write an instance of <see cref="IDependency" />
     /// to the XMI document
     /// </summary>
-    public static class DependencyWriter
+    public class DependencyWriter : XmiDataWriter<IDependency>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<DependencyWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DependencyWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public DependencyWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<DependencyWriter>.Instance : loggerFactory.CreateLogger<DependencyWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IDependency" /> object to its XML representation
         /// </summary>
@@ -49,153 +70,422 @@ public static class DependencyWriter
         /// <param name="poco">The <see cref="IDependency" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IDependency poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDependency poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Dependency");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.Client != null)
             {
                 foreach (var item in poco.Client)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "client", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "client", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.Supplier != null)
             {
                 foreach (var item in poco.Supplier)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "supplier", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "supplier", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IDependency" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDependency" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Dependency");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (poco.Client != null)
+            {
+                foreach (var item in poco.Client)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "client", elementOriginMap, currentFileUri);
                 }
             }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.Supplier != null)
+            {
+                foreach (var item in poco.Supplier)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "supplier", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs
index b1d5337f4..fbe5fe8df 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="DifferencingWriter" /> is to write an instance of <see cref="IDifferencing" />
     /// to the XMI document
     /// </summary>
-    public static class DifferencingWriter
+    public class DifferencingWriter : XmiDataWriter<IDifferencing>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<DifferencingWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DifferencingWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public DifferencingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<DifferencingWriter>.Instance : loggerFactory.CreateLogger<DifferencingWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IDifferencing" /> object to its XML representation
         /// </summary>
@@ -49,147 +70,416 @@ public static class DifferencingWriter
         /// <param name="poco">The <see cref="IDifferencing" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IDifferencing poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDifferencing poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Differencing");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.DifferencingType != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.DifferencingType, "differencingType", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.DifferencingType, "differencingType", elementOriginMap, currentFileUri);
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.typeDifferenced != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeDifferenced, "typeDifferenced", elementOriginMap, currentFileUri);
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IDifferencing" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDifferencing" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Differencing");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (poco.DifferencingType != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.DifferencingType, "differencingType", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.typeDifferenced != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeDifferenced, "typeDifferenced", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.typeDifferenced, "typeDifferenced", elementOriginMap, currentFileUri);
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs
index 5227ed94a..3afd0ae1f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="DisjoiningWriter" /> is to write an instance of <see cref="IDisjoining" />
     /// to the XMI document
     /// </summary>
-    public static class DisjoiningWriter
+    public class DisjoiningWriter : XmiDataWriter<IDisjoining>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<DisjoiningWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DisjoiningWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public DisjoiningWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<DisjoiningWriter>.Instance : loggerFactory.CreateLogger<DisjoiningWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IDisjoining" /> object to its XML representation
         /// </summary>
@@ -49,151 +70,426 @@ public static class DisjoiningWriter
         /// <param name="poco">The <see cref="IDisjoining" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IDisjoining poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDisjoining poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Disjoining");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.DisjoiningType != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.DisjoiningType, "disjoiningType", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.DisjoiningType, "disjoiningType", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.TypeDisjoined != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypeDisjoined, "typeDisjoined", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypeDisjoined, "typeDisjoined", elementOriginMap, currentFileUri);
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IDisjoining" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDisjoining" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Disjoining");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (poco.DisjoiningType != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.DisjoiningType, "disjoiningType", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+            if (poco.TypeDisjoined != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.TypeDisjoined, "typeDisjoined", elementOriginMap, currentFileUri);
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs
index 62c925d72..a7fb28e52 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
@@ -39,8 +43,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="DocumentationWriter" /> is to write an instance of <see cref="IDocumentation" />
     /// to the XMI document
     /// </summary>
-    public static class DocumentationWriter
+    public class DocumentationWriter : XmiDataWriter<IDocumentation>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<DocumentationWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DocumentationWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public DocumentationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<DocumentationWriter>.Instance : loggerFactory.CreateLogger<DocumentationWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IDocumentation" /> object to its XML representation
         /// </summary>
@@ -48,147 +69,428 @@ public static class DocumentationWriter
         /// <param name="poco">The <see cref="IDocumentation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IDocumentation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Documentation");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.Body))
             {
                 xmlWriter.WriteAttributeString("body", poco.Body);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            if (!string.IsNullOrWhiteSpace(poco.Locale))
-            {
-                xmlWriter.WriteAttributeString("locale", poco.Locale);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Locale))
+            {
+                xmlWriter.WriteAttributeString("locale", poco.Locale);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentedElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.documentedElement, "documentedElement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IDocumentation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IDocumentation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDocumentation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Documentation");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Body))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "body", null, poco.Body);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Locale))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "locale", null, poco.Locale);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentedElement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.documentedElement, "documentedElement", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.documentedElement, "documentedElement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningAnnotatingRelationship != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs
index 94afe6758..8a96c8ee6 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
@@ -42,8 +46,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ElementFilterMembershipWriter" /> is to write an instance of <see cref="IElementFilterMembership" />
     /// to the XMI document
     /// </summary>
-    public static class ElementFilterMembershipWriter
+    public class ElementFilterMembershipWriter : XmiDataWriter<IElementFilterMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ElementFilterMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ElementFilterMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ElementFilterMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ElementFilterMembershipWriter>.Instance : loggerFactory.CreateLogger<ElementFilterMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IElementFilterMembership" /> object to its XML representation
         /// </summary>
@@ -51,160 +72,474 @@ public static class ElementFilterMembershipWriter
         /// <param name="poco">The <see cref="IElementFilterMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IElementFilterMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ElementFilterMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.condition != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.condition, "condition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membershipOwningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IElementFilterMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IElementFilterMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ElementFilterMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.condition != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.condition, "condition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.condition, "condition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membershipOwningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs
index 2dd6a8ec7..0b27ece6a 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -42,8 +46,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="EndFeatureMembershipWriter" /> is to write an instance of <see cref="IEndFeatureMembership" />
     /// to the XMI document
     /// </summary>
-    public static class EndFeatureMembershipWriter
+    public class EndFeatureMembershipWriter : XmiDataWriter<IEndFeatureMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<EndFeatureMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EndFeatureMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public EndFeatureMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<EndFeatureMembershipWriter>.Instance : loggerFactory.CreateLogger<EndFeatureMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IEndFeatureMembership" /> object to its XML representation
         /// </summary>
@@ -51,160 +72,474 @@ public static class EndFeatureMembershipWriter
         /// <param name="poco">The <see cref="IEndFeatureMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EndFeatureMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMemberFeature != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IEndFeatureMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IEndFeatureMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:EndFeatureMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMemberFeature != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs
index 0be12857d..a4917cdd3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -64,8 +68,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="EnumerationDefinitionWriter" /> is to write an instance of <see cref="IEnumerationDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class EnumerationDefinitionWriter
+    public class EnumerationDefinitionWriter : XmiDataWriter<IEnumerationDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<EnumerationDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EnumerationDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public EnumerationDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<EnumerationDefinitionWriter>.Instance : loggerFactory.CreateLogger<EnumerationDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IEnumerationDefinition" /> object to its XML representation
         /// </summary>
@@ -73,541 +94,1665 @@ public static class EnumerationDefinitionWriter
         /// <param name="poco">The <see cref="IEnumerationDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EnumerationDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.enumeratedValue != null)
                 {
                     foreach (var item in poco.enumeratedValue)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "enumeratedValue", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "enumeratedValue", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IEnumerationDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IEnumerationDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:EnumerationDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.enumeratedValue != null)
+                {
+                    foreach (var item in poco.enumeratedValue)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "enumeratedValue", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs
index 3230b8509..cc76f671d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="EnumerationUsageWriter" /> is to write an instance of <see cref="IEnumerationUsage" />
     /// to the XMI document
     /// </summary>
-    public static class EnumerationUsageWriter
+    public class EnumerationUsageWriter : XmiDataWriter<IEnumerationUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<EnumerationUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EnumerationUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public EnumerationUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<EnumerationUsageWriter>.Instance : loggerFactory.CreateLogger<EnumerationUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IEnumerationUsage" /> object to its XML representation
         /// </summary>
@@ -75,667 +96,2085 @@ public static class EnumerationUsageWriter
         /// <param name="poco">The <see cref="IEnumerationUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EnumerationUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.enumerationDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.enumerationDefinition, "enumerationDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.enumerationDefinition, "enumerationDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUseCase != null)
-                {
-                    foreach (var item in poco.nestedUseCase)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IEnumerationUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IEnumerationUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:EnumerationUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.enumerationDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.enumerationDefinition, "enumerationDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs
index 990263f20..72450b1ab 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -67,8 +71,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="EventOccurrenceUsageWriter" /> is to write an instance of <see cref="IEventOccurrenceUsage" />
     /// to the XMI document
     /// </summary>
-    public static class EventOccurrenceUsageWriter
+    public class EventOccurrenceUsageWriter : XmiDataWriter<IEventOccurrenceUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<EventOccurrenceUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EventOccurrenceUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public EventOccurrenceUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<EventOccurrenceUsageWriter>.Instance : loggerFactory.CreateLogger<EventOccurrenceUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IEventOccurrenceUsage" /> object to its XML representation
         /// </summary>
@@ -76,683 +97,2137 @@ public static class EventOccurrenceUsageWriter
         /// <param name="poco">The <see cref="IEventOccurrenceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EventOccurrenceUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.eventOccurrence != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.eventOccurrence, "eventOccurrence", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.eventOccurrence, "eventOccurrence", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedTransition != null)
-                {
-                    foreach (var item in poco.nestedTransition)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IEventOccurrenceUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IEventOccurrenceUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:EventOccurrenceUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.eventOccurrence != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.eventOccurrence, "eventOccurrence", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs
index cd7a0bc9e..77084fc17 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ExhibitStateUsageWriter" /> is to write an instance of <see cref="IExhibitStateUsage" />
     /// to the XMI document
     /// </summary>
-    public static class ExhibitStateUsageWriter
+    public class ExhibitStateUsageWriter : XmiDataWriter<IExhibitStateUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ExhibitStateUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExhibitStateUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ExhibitStateUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ExhibitStateUsageWriter>.Instance : loggerFactory.CreateLogger<ExhibitStateUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IExhibitStateUsage" /> object to its XML representation
         /// </summary>
@@ -77,706 +98,2217 @@ public static class ExhibitStateUsageWriter
         /// <param name="poco">The <see cref="IExhibitStateUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ExhibitStateUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsParallel)
             {
                 xmlWriter.WriteAttributeString("isParallel", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.doAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.entryAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.exhibitedState != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exhibitedState, "exhibitedState", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exhibitedState, "exhibitedState", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.exitAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedRequirement != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.stateDefinition != null)
                 {
                     foreach (var item in poco.stateDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stateDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stateDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IExhibitStateUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IExhibitStateUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ExhibitStateUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsParallel)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isParallel", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.doAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.entryAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.exhibitedState != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.exhibitedState, "exhibitedState", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.exitAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.stateDefinition != null)
+                {
+                    foreach (var item in poco.stateDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stateDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs
index 3c2d27291..4de808076 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ExpressionWriter" /> is to write an instance of <see cref="IExpression" />
     /// to the XMI document
     /// </summary>
-    public static class ExpressionWriter
+    public class ExpressionWriter : XmiDataWriter<IExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ExpressionWriter>.Instance : loggerFactory.CreateLogger<ExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IExpression" /> object to its XML representation
         /// </summary>
@@ -53,449 +74,1393 @@ public static class ExpressionWriter
         /// <param name="poco">The <see cref="IExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Expression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Expression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs
index 407bcec76..5abfe1668 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FeatureChainExpressionWriter" /> is to write an instance of <see cref="IFeatureChainExpression" />
     /// to the XMI document
     /// </summary>
-    public static class FeatureChainExpressionWriter
+    public class FeatureChainExpressionWriter : XmiDataWriter<IFeatureChainExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FeatureChainExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FeatureChainExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FeatureChainExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FeatureChainExpressionWriter>.Instance : loggerFactory.CreateLogger<FeatureChainExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFeatureChainExpression" /> object to its XML representation
         /// </summary>
@@ -54,468 +75,1457 @@ public static class FeatureChainExpressionWriter
         /// <param name="poco">The <see cref="IFeatureChainExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureChainExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
-            {
-                xmlWriter.WriteAttributeString("operator", poco.Operator);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                xmlWriter.WriteAttributeString("operator", poco.Operator);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.instantiatedType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedTypeFeaturing != null)
-                {
-                    foreach (var item in poco.ownedTypeFeaturing)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetFeature, "targetFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetFeature, "targetFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFeatureChainExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureChainExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureChainExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.instantiatedType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetFeature, "targetFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs
index 41118a19c..e1084f51f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FeatureChainingWriter" /> is to write an instance of <see cref="IFeatureChaining" />
     /// to the XMI document
     /// </summary>
-    public static class FeatureChainingWriter
+    public class FeatureChainingWriter : XmiDataWriter<IFeatureChaining>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FeatureChainingWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FeatureChainingWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FeatureChainingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FeatureChainingWriter>.Instance : loggerFactory.CreateLogger<FeatureChainingWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFeatureChaining" /> object to its XML representation
         /// </summary>
@@ -49,147 +70,416 @@ public static class FeatureChainingWriter
         /// <param name="poco">The <see cref="IFeatureChaining" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFeatureChaining poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureChaining");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.ChainingFeature != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ChainingFeature, "chainingFeature", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ChainingFeature, "chainingFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureChained != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureChained, "featureChained", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFeatureChaining" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureChaining" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureChaining");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (poco.ChainingFeature != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ChainingFeature, "chainingFeature", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureChained != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureChained, "featureChained", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureChained, "featureChained", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs
index 8c9184a16..546b7cb44 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FeatureInvertingWriter" /> is to write an instance of <see cref="IFeatureInverting" />
     /// to the XMI document
     /// </summary>
-    public static class FeatureInvertingWriter
+    public class FeatureInvertingWriter : XmiDataWriter<IFeatureInverting>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FeatureInvertingWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FeatureInvertingWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FeatureInvertingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FeatureInvertingWriter>.Instance : loggerFactory.CreateLogger<FeatureInvertingWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFeatureInverting" /> object to its XML representation
         /// </summary>
@@ -49,151 +70,426 @@ public static class FeatureInvertingWriter
         /// <param name="poco">The <see cref="IFeatureInverting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFeatureInverting poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureInverting");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.FeatureInverted != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeatureInverted, "featureInverted", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeatureInverted, "featureInverted", elementOriginMap, currentFileUri);
             }
+
             if (poco.InvertingFeature != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.InvertingFeature, "invertingFeature", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.InvertingFeature, "invertingFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeature != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFeatureInverting" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureInverting" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureInverting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureInverting");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.FeatureInverted != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.FeatureInverted, "featureInverted", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.InvertingFeature != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.InvertingFeature, "invertingFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs
index 0325e0fe0..99ba7ee04 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -42,8 +46,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FeatureMembershipWriter" /> is to write an instance of <see cref="IFeatureMembership" />
     /// to the XMI document
     /// </summary>
-    public static class FeatureMembershipWriter
+    public class FeatureMembershipWriter : XmiDataWriter<IFeatureMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FeatureMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FeatureMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FeatureMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FeatureMembershipWriter>.Instance : loggerFactory.CreateLogger<FeatureMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFeatureMembership" /> object to its XML representation
         /// </summary>
@@ -51,160 +72,474 @@ public static class FeatureMembershipWriter
         /// <param name="poco">The <see cref="IFeatureMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFeatureMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMemberFeature != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFeatureMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMemberFeature != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs
index 6c15f7f18..ed6aa2d60 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FeatureReferenceExpressionWriter" /> is to write an instance of <see cref="IFeatureReferenceExpression" />
     /// to the XMI document
     /// </summary>
-    public static class FeatureReferenceExpressionWriter
+    public class FeatureReferenceExpressionWriter : XmiDataWriter<IFeatureReferenceExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FeatureReferenceExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FeatureReferenceExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FeatureReferenceExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FeatureReferenceExpressionWriter>.Instance : loggerFactory.CreateLogger<FeatureReferenceExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFeatureReferenceExpression" /> object to its XML representation
         /// </summary>
@@ -54,453 +75,1409 @@ public static class FeatureReferenceExpressionWriter
         /// <param name="poco">The <see cref="IFeatureReferenceExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureReferenceExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.referent != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFeatureReferenceExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureReferenceExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureReferenceExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.referent != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs
index 70c5d32e2..9575d8e97 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FeatureTypingWriter" /> is to write an instance of <see cref="IFeatureTyping" />
     /// to the XMI document
     /// </summary>
-    public static class FeatureTypingWriter
+    public class FeatureTypingWriter : XmiDataWriter<IFeatureTyping>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FeatureTypingWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FeatureTypingWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FeatureTypingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FeatureTypingWriter>.Instance : loggerFactory.CreateLogger<FeatureTypingWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFeatureTyping" /> object to its XML representation
         /// </summary>
@@ -50,151 +71,426 @@ public static class FeatureTypingWriter
         /// <param name="poco">The <see cref="IFeatureTyping" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureTyping");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeature != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.Type != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Type, "type", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Type, "type", elementOriginMap, currentFileUri);
             }
+
             if (poco.TypedFeature != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFeatureTyping" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureTyping" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureTyping poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureTyping");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+            if (poco.Type != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.Type, "type", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.TypedFeature != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs
index 9bf133964..c3330b93f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FeatureValueWriter" /> is to write an instance of <see cref="IFeatureValue" />
     /// to the XMI document
     /// </summary>
-    public static class FeatureValueWriter
+    public class FeatureValueWriter : XmiDataWriter<IFeatureValue>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FeatureValueWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FeatureValueWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FeatureValueWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FeatureValueWriter>.Instance : loggerFactory.CreateLogger<FeatureValueWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFeatureValue" /> object to its XML representation
         /// </summary>
@@ -52,172 +73,510 @@ public static class FeatureValueWriter
         /// <param name="poco">The <see cref="IFeatureValue" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFeatureValue poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureValue");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsDefault)
             {
                 xmlWriter.WriteAttributeString("isDefault", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsInitial)
             {
                 xmlWriter.WriteAttributeString("isInitial", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureWithValue != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureWithValue, "featureWithValue", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membershipOwningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.value != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.value, "value", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFeatureValue" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeatureValue" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureValue");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsDefault)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDefault", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsInitial)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isInitial", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureWithValue != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureWithValue, "featureWithValue", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureWithValue, "featureWithValue", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membershipOwningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.value != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.value, "value", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.value, "value", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs
index 6122909b7..a7edea580 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -42,8 +46,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FeatureWriter" /> is to write an instance of <see cref="IFeature" />
     /// to the XMI document
     /// </summary>
-    public static class FeatureWriter
+    public class FeatureWriter : XmiDataWriter<IFeature>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FeatureWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FeatureWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FeatureWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FeatureWriter>.Instance : loggerFactory.CreateLogger<FeatureWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFeature" /> object to its XML representation
         /// </summary>
@@ -51,437 +72,1345 @@ public static class FeatureWriter
         /// <param name="poco">The <see cref="IFeature" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFeature poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Feature");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
-                if (poco.owningType != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
-                }
-                if (poco.textualRepresentation != null)
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFeature" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFeature" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Feature");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs
index 094081cc5..62c73628b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -67,8 +71,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FlowDefinitionWriter" /> is to write an instance of <see cref="IFlowDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class FlowDefinitionWriter
+    public class FlowDefinitionWriter : XmiDataWriter<IFlowDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FlowDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FlowDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FlowDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FlowDefinitionWriter>.Instance : loggerFactory.CreateLogger<FlowDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFlowDefinition" /> object to its XML representation
         /// </summary>
@@ -76,592 +97,1815 @@ public static class FlowDefinitionWriter
         /// <param name="poco">The <see cref="IFlowDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFlowDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FlowDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.flowEnd != null)
                 {
                     foreach (var item in poco.flowEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedRendering != null)
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
                 {
-                    foreach (var item in poco.ownedRendering)
-                    {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFlowDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFlowDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FlowDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.flowEnd != null)
+                {
+                    foreach (var item in poco.flowEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs
index ea28d979b..3984e043f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FlowEndWriter" /> is to write an instance of <see cref="IFlowEnd" />
     /// to the XMI document
     /// </summary>
-    public static class FlowEndWriter
+    public class FlowEndWriter : XmiDataWriter<IFlowEnd>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FlowEndWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FlowEndWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FlowEndWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FlowEndWriter>.Instance : loggerFactory.CreateLogger<FlowEndWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFlowEnd" /> object to its XML representation
         /// </summary>
@@ -52,437 +73,1345 @@ public static class FlowEndWriter
         /// <param name="poco">The <see cref="IFlowEnd" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FlowEnd");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
-                if (poco.owningType != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
-                }
-                if (poco.textualRepresentation != null)
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFlowEnd" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFlowEnd" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FlowEnd");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs
index d259a96e1..ba4e45c77 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -71,8 +75,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FlowUsageWriter" /> is to write an instance of <see cref="IFlowUsage" />
     /// to the XMI document
     /// </summary>
-    public static class FlowUsageWriter
+    public class FlowUsageWriter : XmiDataWriter<IFlowUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FlowUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FlowUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FlowUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FlowUsageWriter>.Instance : loggerFactory.CreateLogger<FlowUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFlowUsage" /> object to its XML representation
         /// </summary>
@@ -80,756 +101,2369 @@ public static class FlowUsageWriter
         /// <param name="poco">The <see cref="IFlowUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FlowUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.flowDefinition != null)
                 {
                     foreach (var item in poco.flowDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.flowEnd != null)
                 {
                     foreach (var item in poco.flowEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedReference != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadType != null)
                 {
                     foreach (var item in poco.payloadType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceOutputFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetInputFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFlowUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFlowUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FlowUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.flowDefinition != null)
+                {
+                    foreach (var item in poco.flowDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.flowEnd != null)
+                {
+                    foreach (var item in poco.flowEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadType != null)
+                {
+                    foreach (var item in poco.payloadType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceOutputFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetInputFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs
index a5fbfcbf0..db6c20152 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -47,8 +51,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FlowWriter" /> is to write an instance of <see cref="IFlow" />
     /// to the XMI document
     /// </summary>
-    public static class FlowWriter
+    public class FlowWriter : XmiDataWriter<IFlow>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FlowWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FlowWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FlowWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FlowWriter>.Instance : loggerFactory.CreateLogger<FlowWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFlow" /> object to its XML representation
         /// </summary>
@@ -56,500 +77,1549 @@ public static class FlowWriter
         /// <param name="poco">The <see cref="IFlow" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFlow poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Flow");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.flowEnd != null)
                 {
                     foreach (var item in poco.flowEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.interaction != null)
                 {
                     foreach (var item in poco.interaction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interaction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interaction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedTyping != null)
-                {
-                    foreach (var item in poco.ownedTyping)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadType != null)
                 {
                     foreach (var item in poco.payloadType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceOutputFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetInputFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFlow" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFlow" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Flow");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.flowEnd != null)
+                {
+                    foreach (var item in poco.flowEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.interaction != null)
+                {
+                    foreach (var item in poco.interaction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "interaction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadType != null)
+                {
+                    foreach (var item in poco.payloadType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceOutputFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetInputFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs
index 8736aa640..7030de5d0 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ForLoopActionUsageWriter" /> is to write an instance of <see cref="IForLoopActionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class ForLoopActionUsageWriter
+    public class ForLoopActionUsageWriter : XmiDataWriter<IForLoopActionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ForLoopActionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ForLoopActionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ForLoopActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ForLoopActionUsageWriter>.Instance : loggerFactory.CreateLogger<ForLoopActionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IForLoopActionUsage" /> object to its XML representation
         /// </summary>
@@ -78,698 +99,2191 @@ public static class ForLoopActionUsageWriter
         /// <param name="poco">The <see cref="IForLoopActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ForLoopActionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.bodyAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.loopVariable != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.loopVariable, "loopVariable", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.loopVariable, "loopVariable", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedState != null)
-                {
-                    foreach (var item in poco.nestedState)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.seqArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.seqArgument, "seqArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.seqArgument, "seqArgument", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IForLoopActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IForLoopActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ForLoopActionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.bodyAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.loopVariable != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.loopVariable, "loopVariable", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.seqArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.seqArgument, "seqArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs
index b1829e891..fca8d0acb 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ForkNodeWriter" /> is to write an instance of <see cref="IForkNode" />
     /// to the XMI document
     /// </summary>
-    public static class ForkNodeWriter
+    public class ForkNodeWriter : XmiDataWriter<IForkNode>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ForkNodeWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ForkNodeWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ForkNodeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ForkNodeWriter>.Instance : loggerFactory.CreateLogger<ForkNodeWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IForkNode" /> object to its XML representation
         /// </summary>
@@ -77,686 +98,2143 @@ public static class ForkNodeWriter
         /// <param name="poco">The <see cref="IForkNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IForkNode poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ForkNode");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IForkNode" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IForkNode" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ForkNode");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs
index 3d9e637dd..333eba323 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.Requirements;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FramedConcernMembershipWriter" /> is to write an instance of <see cref="IFramedConcernMembership" />
     /// to the XMI document
     /// </summary>
-    public static class FramedConcernMembershipWriter
+    public class FramedConcernMembershipWriter : XmiDataWriter<IFramedConcernMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FramedConcernMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FramedConcernMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FramedConcernMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FramedConcernMembershipWriter>.Instance : loggerFactory.CreateLogger<FramedConcernMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFramedConcernMembership" /> object to its XML representation
         /// </summary>
@@ -54,165 +75,494 @@ public static class FramedConcernMembershipWriter
         /// <param name="poco">The <see cref="IFramedConcernMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FramedConcernMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConcern, "ownedConcern", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.referencedConcern != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedConcern, "referencedConcern", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFramedConcernMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFramedConcernMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FramedConcernMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConcern, "ownedConcern", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConcern, "ownedConcern", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.referencedConcern != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedConcern, "referencedConcern", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referencedConcern, "referencedConcern", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs
index 7b63a1953..d9ccbc048 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="FunctionWriter" /> is to write an instance of <see cref="IFunction" />
     /// to the XMI document
     /// </summary>
-    public static class FunctionWriter
+    public class FunctionWriter : XmiDataWriter<IFunction>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<FunctionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FunctionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public FunctionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<FunctionWriter>.Instance : loggerFactory.CreateLogger<FunctionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IFunction" /> object to its XML representation
         /// </summary>
@@ -53,342 +74,1049 @@ public static class FunctionWriter
         /// <param name="poco">The <see cref="IFunction" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IFunction poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFunction poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Function");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
-            {
-                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
-            }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
                     xmlWriter.WriteAttributeString("isConjugated", "true");
                 }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IFunction" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IFunction" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Function");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs
index 1ae561e4e..2f68039ae 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="IfActionUsageWriter" /> is to write an instance of <see cref="IIfActionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class IfActionUsageWriter
+    public class IfActionUsageWriter : XmiDataWriter<IIfActionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<IfActionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IfActionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public IfActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<IfActionUsageWriter>.Instance : loggerFactory.CreateLogger<IfActionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IIfActionUsage" /> object to its XML representation
         /// </summary>
@@ -78,698 +99,2191 @@ public static class IfActionUsageWriter
         /// <param name="poco">The <see cref="IIfActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:IfActionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.elseAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.elseAction, "elseAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.elseAction, "elseAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ifArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ifArgument, "ifArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ifArgument, "ifArgument", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedState != null)
-                {
-                    foreach (var item in poco.nestedState)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.thenAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.thenAction, "thenAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.thenAction, "thenAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IIfActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IIfActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:IfActionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.elseAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.elseAction, "elseAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ifArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ifArgument, "ifArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.thenAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.thenAction, "thenAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs
index 67db75402..f5230a939 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="IncludeUseCaseUsageWriter" /> is to write an instance of <see cref="IIncludeUseCaseUsage" />
     /// to the XMI document
     /// </summary>
-    public static class IncludeUseCaseUsageWriter
+    public class IncludeUseCaseUsageWriter : XmiDataWriter<IIncludeUseCaseUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<IncludeUseCaseUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IncludeUseCaseUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public IncludeUseCaseUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<IncludeUseCaseUsageWriter>.Instance : loggerFactory.CreateLogger<IncludeUseCaseUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IIncludeUseCaseUsage" /> object to its XML representation
         /// </summary>
@@ -78,724 +99,2283 @@ public static class IncludeUseCaseUsageWriter
         /// <param name="poco">The <see cref="IIncludeUseCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:IncludeUseCaseUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.includedUseCase != null)
                 {
                     foreach (var item in poco.includedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedReference != null)
-                {
-                    foreach (var item in poco.nestedReference)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.objectiveRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.useCaseDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.useCaseIncluded != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseIncluded, "useCaseIncluded", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseIncluded, "useCaseIncluded", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IIncludeUseCaseUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IIncludeUseCaseUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:IncludeUseCaseUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.includedUseCase != null)
+                {
+                    foreach (var item in poco.includedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.objectiveRequirement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.useCaseDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.useCaseIncluded != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.useCaseIncluded, "useCaseIncluded", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs
index e501f7f79..8c9e566bf 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="IndexExpressionWriter" /> is to write an instance of <see cref="IIndexExpression" />
     /// to the XMI document
     /// </summary>
-    public static class IndexExpressionWriter
+    public class IndexExpressionWriter : XmiDataWriter<IIndexExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<IndexExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IndexExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public IndexExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<IndexExpressionWriter>.Instance : loggerFactory.CreateLogger<IndexExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IIndexExpression" /> object to its XML representation
         /// </summary>
@@ -54,464 +75,1441 @@ public static class IndexExpressionWriter
         /// <param name="poco">The <see cref="IIndexExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IIndexExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:IndexExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
-            {
-                xmlWriter.WriteAttributeString("operator", poco.Operator);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                xmlWriter.WriteAttributeString("operator", poco.Operator);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.instantiatedType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedTypeFeaturing != null)
-                {
-                    foreach (var item in poco.ownedTypeFeaturing)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IIndexExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IIndexExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:IndexExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.instantiatedType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs
index fc9537627..fac313ed9 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="InteractionWriter" /> is to write an instance of <see cref="IInteraction" />
     /// to the XMI document
     /// </summary>
-    public static class InteractionWriter
+    public class InteractionWriter : XmiDataWriter<IInteraction>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<InteractionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InteractionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public InteractionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<InteractionWriter>.Instance : loggerFactory.CreateLogger<InteractionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IInteraction" /> object to its XML representation
         /// </summary>
@@ -54,360 +75,1091 @@ public static class InteractionWriter
         /// <param name="poco">The <see cref="IInteraction" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IInteraction poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IInteraction poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Interaction");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.associationEnd != null)
                 {
                     foreach (var item in poco.associationEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IInteraction" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IInteraction" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Interaction");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.associationEnd != null)
+                {
+                    foreach (var item in poco.associationEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs
index 75c65617c..8c3c42a1f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="InterfaceDefinitionWriter" /> is to write an instance of <see cref="IInterfaceDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class InterfaceDefinitionWriter
+    public class InterfaceDefinitionWriter : XmiDataWriter<IInterfaceDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<InterfaceDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InterfaceDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public InterfaceDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<InterfaceDefinitionWriter>.Instance : loggerFactory.CreateLogger<InterfaceDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IInterfaceDefinition" /> object to its XML representation
         /// </summary>
@@ -74,578 +95,1771 @@ public static class InterfaceDefinitionWriter
         /// <param name="poco">The <see cref="IInterfaceDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:InterfaceDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.interfaceEnd != null)
                 {
                     foreach (var item in poco.interfaceEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interfaceEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interfaceEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedRendering != null)
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
                 {
-                    foreach (var item in poco.ownedRendering)
-                    {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IInterfaceDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IInterfaceDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:InterfaceDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.interfaceEnd != null)
+                {
+                    foreach (var item in poco.interfaceEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "interfaceEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedType != null)
+                {
+                    foreach (var item in poco.relatedType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetType != null)
+                {
+                    foreach (var item in poco.targetType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs
index 8c13792f5..f82d8c4b4 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -70,8 +74,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="InterfaceUsageWriter" /> is to write an instance of <see cref="IInterfaceUsage" />
     /// to the XMI document
     /// </summary>
-    public static class InterfaceUsageWriter
+    public class InterfaceUsageWriter : XmiDataWriter<IInterfaceUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<InterfaceUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InterfaceUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public InterfaceUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<InterfaceUsageWriter>.Instance : loggerFactory.CreateLogger<InterfaceUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IInterfaceUsage" /> object to its XML representation
         /// </summary>
@@ -79,737 +100,2299 @@ public static class InterfaceUsageWriter
         /// <param name="poco">The <see cref="IInterfaceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:InterfaceUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.interfaceDefinition != null)
                 {
                     foreach (var item in poco.interfaceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interfaceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interfaceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedReference != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.partDefinition != null)
                 {
                     foreach (var item in poco.partDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IInterfaceUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IInterfaceUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:InterfaceUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.interfaceDefinition != null)
+                {
+                    foreach (var item in poco.interfaceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "interfaceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.partDefinition != null)
+                {
+                    foreach (var item in poco.partDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs
index a75a99dcf..edced38ce 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="IntersectingWriter" /> is to write an instance of <see cref="IIntersecting" />
     /// to the XMI document
     /// </summary>
-    public static class IntersectingWriter
+    public class IntersectingWriter : XmiDataWriter<IIntersecting>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<IntersectingWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IntersectingWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public IntersectingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<IntersectingWriter>.Instance : loggerFactory.CreateLogger<IntersectingWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IIntersecting" /> object to its XML representation
         /// </summary>
@@ -49,147 +70,416 @@ public static class IntersectingWriter
         /// <param name="poco">The <see cref="IIntersecting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IIntersecting poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IIntersecting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Intersecting");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.IntersectingType != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.IntersectingType, "intersectingType", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.IntersectingType, "intersectingType", elementOriginMap, currentFileUri);
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.typeIntersected != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeIntersected, "typeIntersected", elementOriginMap, currentFileUri);
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IIntersecting" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IIntersecting" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IIntersecting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Intersecting");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.IntersectingType != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.IntersectingType, "intersectingType", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.typeIntersected != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeIntersected, "typeIntersected", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.typeIntersected, "typeIntersected", elementOriginMap, currentFileUri);
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs
index 3efd64578..70c78f5c3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="InvariantWriter" /> is to write an instance of <see cref="IInvariant" />
     /// to the XMI document
     /// </summary>
-    public static class InvariantWriter
+    public class InvariantWriter : XmiDataWriter<IInvariant>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<InvariantWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvariantWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public InvariantWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<InvariantWriter>.Instance : loggerFactory.CreateLogger<InvariantWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IInvariant" /> object to its XML representation
         /// </summary>
@@ -53,453 +74,1403 @@ public static class InvariantWriter
         /// <param name="poco">The <see cref="IInvariant" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IInvariant poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Invariant");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsNegated)
             {
                 xmlWriter.WriteAttributeString("isNegated", "true");
             }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-                if (poco.owningMembership != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.predicate != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IInvariant" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IInvariant" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Invariant");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsNegated)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isNegated", null, "true");
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.predicate != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs
index b1188aea8..d3aa25fb3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="InvocationExpressionWriter" /> is to write an instance of <see cref="IInvocationExpression" />
     /// to the XMI document
     /// </summary>
-    public static class InvocationExpressionWriter
+    public class InvocationExpressionWriter : XmiDataWriter<IInvocationExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<InvocationExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvocationExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public InvocationExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<InvocationExpressionWriter>.Instance : loggerFactory.CreateLogger<InvocationExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IInvocationExpression" /> object to its XML representation
         /// </summary>
@@ -54,460 +75,1431 @@ public static class InvocationExpressionWriter
         /// <param name="poco">The <see cref="IInvocationExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IInvocationExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:InvocationExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.instantiatedType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IInvocationExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IInvocationExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:InvocationExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.instantiatedType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs
index be4febcd9..c30f52a55 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ItemDefinitionWriter" /> is to write an instance of <see cref="IItemDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class ItemDefinitionWriter
+    public class ItemDefinitionWriter : XmiDataWriter<IItemDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ItemDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ItemDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ItemDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ItemDefinitionWriter>.Instance : loggerFactory.CreateLogger<ItemDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IItemDefinition" /> object to its XML representation
         /// </summary>
@@ -74,545 +95,1675 @@ public static class ItemDefinitionWriter
         /// <param name="poco">The <see cref="IItemDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IItemDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ItemDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedSpecialization != null)
-                {
-                    foreach (var item in poco.ownedSpecialization)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IItemDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IItemDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ItemDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs
index b617cff6f..7c91f8170 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ItemUsageWriter" /> is to write an instance of <see cref="IItemUsage" />
     /// to the XMI document
     /// </summary>
-    public static class ItemUsageWriter
+    public class ItemUsageWriter : XmiDataWriter<IItemUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ItemUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ItemUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ItemUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ItemUsageWriter>.Instance : loggerFactory.CreateLogger<ItemUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IItemUsage" /> object to its XML representation
         /// </summary>
@@ -77,686 +98,2143 @@ public static class ItemUsageWriter
         /// <param name="poco">The <see cref="IItemUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IItemUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ItemUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedTransition != null)
-                {
-                    foreach (var item in poco.nestedTransition)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IItemUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IItemUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ItemUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs
index b6feb3b8b..3688f72c8 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="JoinNodeWriter" /> is to write an instance of <see cref="IJoinNode" />
     /// to the XMI document
     /// </summary>
-    public static class JoinNodeWriter
+    public class JoinNodeWriter : XmiDataWriter<IJoinNode>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<JoinNodeWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JoinNodeWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public JoinNodeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<JoinNodeWriter>.Instance : loggerFactory.CreateLogger<JoinNodeWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IJoinNode" /> object to its XML representation
         /// </summary>
@@ -77,686 +98,2143 @@ public static class JoinNodeWriter
         /// <param name="poco">The <see cref="IJoinNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IJoinNode poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:JoinNode");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IJoinNode" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IJoinNode" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:JoinNode");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs
index 46c596ac5..79f995e1c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="LibraryPackageWriter" /> is to write an instance of <see cref="ILibraryPackage" />
     /// to the XMI document
     /// </summary>
-    public static class LibraryPackageWriter
+    public class LibraryPackageWriter : XmiDataWriter<ILibraryPackage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<LibraryPackageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LibraryPackageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public LibraryPackageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<LibraryPackageWriter>.Instance : loggerFactory.CreateLogger<LibraryPackageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ILibraryPackage" /> object to its XML representation
         /// </summary>
@@ -50,170 +71,496 @@ public static class LibraryPackageWriter
         /// <param name="poco">The <see cref="ILibraryPackage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ILibraryPackage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LibraryPackage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            if (poco.IsStandard)
-            {
-                xmlWriter.WriteAttributeString("isStandard", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsStandard)
+            {
+                xmlWriter.WriteAttributeString("isStandard", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.filterCondition != null)
+                {
+                    foreach (var item in poco.filterCondition)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "filterCondition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ILibraryPackage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILibraryPackage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILibraryPackage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LibraryPackage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsStandard)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isStandard", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.filterCondition != null)
                 {
                     foreach (var item in poco.filterCondition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "filterCondition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "filterCondition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs
index 346ed9ee3..f72d75cb3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="LiteralBooleanWriter" /> is to write an instance of <see cref="ILiteralBoolean" />
     /// to the XMI document
     /// </summary>
-    public static class LiteralBooleanWriter
+    public class LiteralBooleanWriter : XmiDataWriter<ILiteralBoolean>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<LiteralBooleanWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LiteralBooleanWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public LiteralBooleanWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<LiteralBooleanWriter>.Instance : loggerFactory.CreateLogger<LiteralBooleanWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ILiteralBoolean" /> object to its XML representation
         /// </summary>
@@ -54,453 +75,1403 @@ public static class LiteralBooleanWriter
         /// <param name="poco">The <see cref="ILiteralBoolean" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralBoolean");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
-            if (poco.Value)
-            {
-                xmlWriter.WriteAttributeString("value", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
+
+            if (poco.Value)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                xmlWriter.WriteAttributeString("value", "true");
             }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.owner != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ILiteralBoolean" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralBoolean" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralBoolean");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            if (poco.Value)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "value", null, "true");
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs
index 6bd58cf87..3a8f7edec 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="LiteralExpressionWriter" /> is to write an instance of <see cref="ILiteralExpression" />
     /// to the XMI document
     /// </summary>
-    public static class LiteralExpressionWriter
+    public class LiteralExpressionWriter : XmiDataWriter<ILiteralExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<LiteralExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LiteralExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public LiteralExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<LiteralExpressionWriter>.Instance : loggerFactory.CreateLogger<LiteralExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ILiteralExpression" /> object to its XML representation
         /// </summary>
@@ -54,449 +75,1393 @@ public static class LiteralExpressionWriter
         /// <param name="poco">The <see cref="ILiteralExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ILiteralExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ILiteralExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs
index 00235584d..c95db689d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="LiteralInfinityWriter" /> is to write an instance of <see cref="ILiteralInfinity" />
     /// to the XMI document
     /// </summary>
-    public static class LiteralInfinityWriter
+    public class LiteralInfinityWriter : XmiDataWriter<ILiteralInfinity>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<LiteralInfinityWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LiteralInfinityWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public LiteralInfinityWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<LiteralInfinityWriter>.Instance : loggerFactory.CreateLogger<LiteralInfinityWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ILiteralInfinity" /> object to its XML representation
         /// </summary>
@@ -54,449 +75,1393 @@ public static class LiteralInfinityWriter
         /// <param name="poco">The <see cref="ILiteralInfinity" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralInfinity");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ILiteralInfinity" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralInfinity" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralInfinity");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs
index 7532b5737..ce9e83ec4 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="LiteralIntegerWriter" /> is to write an instance of <see cref="ILiteralInteger" />
     /// to the XMI document
     /// </summary>
-    public static class LiteralIntegerWriter
+    public class LiteralIntegerWriter : XmiDataWriter<ILiteralInteger>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<LiteralIntegerWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LiteralIntegerWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public LiteralIntegerWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<LiteralIntegerWriter>.Instance : loggerFactory.CreateLogger<LiteralIntegerWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ILiteralInteger" /> object to its XML representation
         /// </summary>
@@ -54,450 +75,1397 @@ public static class LiteralIntegerWriter
         /// <param name="poco">The <see cref="ILiteralInteger" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ILiteralInteger poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralInteger");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
-            xmlWriter.WriteAttributeString("value", poco.Value.ToString(CultureInfo.InvariantCulture));
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("value", poco.Value.ToString(CultureInfo.InvariantCulture));
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
-                if (poco.owningFeatureMembership != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ILiteralInteger" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralInteger" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralInteger");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "value", null, poco.Value.ToString(CultureInfo.InvariantCulture));
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs
index 452586c01..d774cc151 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="LiteralRationalWriter" /> is to write an instance of <see cref="ILiteralRational" />
     /// to the XMI document
     /// </summary>
-    public static class LiteralRationalWriter
+    public class LiteralRationalWriter : XmiDataWriter<ILiteralRational>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<LiteralRationalWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LiteralRationalWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public LiteralRationalWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<LiteralRationalWriter>.Instance : loggerFactory.CreateLogger<LiteralRationalWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ILiteralRational" /> object to its XML representation
         /// </summary>
@@ -54,450 +75,1397 @@ public static class LiteralRationalWriter
         /// <param name="poco">The <see cref="ILiteralRational" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ILiteralRational poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralRational");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
-            xmlWriter.WriteAttributeString("value", poco.Value.ToString(CultureInfo.InvariantCulture));
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("value", poco.Value.ToString(CultureInfo.InvariantCulture));
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
-                if (poco.owningFeatureMembership != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ILiteralRational" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralRational" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralRational");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "value", null, poco.Value.ToString(CultureInfo.InvariantCulture));
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs
index 4ca6a580a..bec6b04fd 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="LiteralStringWriter" /> is to write an instance of <see cref="ILiteralString" />
     /// to the XMI document
     /// </summary>
-    public static class LiteralStringWriter
+    public class LiteralStringWriter : XmiDataWriter<ILiteralString>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<LiteralStringWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LiteralStringWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public LiteralStringWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<LiteralStringWriter>.Instance : loggerFactory.CreateLogger<LiteralStringWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ILiteralString" /> object to its XML representation
         /// </summary>
@@ -54,453 +75,1403 @@ public static class LiteralStringWriter
         /// <param name="poco">The <see cref="ILiteralString" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ILiteralString poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralString");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
-            if (!string.IsNullOrWhiteSpace(poco.Value))
-            {
-                xmlWriter.WriteAttributeString("value", poco.Value);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
+
+            if (!string.IsNullOrWhiteSpace(poco.Value))
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                xmlWriter.WriteAttributeString("value", poco.Value);
             }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.owner != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ILiteralString" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ILiteralString" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralString");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Value))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "value", null, poco.Value);
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs
index 48be34bb2..760366253 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MembershipExposeWriter" /> is to write an instance of <see cref="IMembershipExpose" />
     /// to the XMI document
     /// </summary>
-    public static class MembershipExposeWriter
+    public class MembershipExposeWriter : XmiDataWriter<IMembershipExpose>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MembershipExposeWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MembershipExposeWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MembershipExposeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MembershipExposeWriter>.Instance : loggerFactory.CreateLogger<MembershipExposeWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMembershipExpose" /> object to its XML representation
         /// </summary>
@@ -50,160 +71,456 @@ public static class MembershipExposeWriter
         /// <param name="poco">The <see cref="IMembershipExpose" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMembershipExpose poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MembershipExpose");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsImportAll)
             {
                 xmlWriter.WriteAttributeString("isImportAll", "true");
             }
-            if (poco.IsRecursive)
-            {
-                xmlWriter.WriteAttributeString("isRecursive", "true");
-            }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsRecursive)
+            {
+                xmlWriter.WriteAttributeString("isRecursive", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.ImportedMembership != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importOwningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMembershipExpose" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMembershipExpose" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipExpose poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MembershipExpose");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsImportAll)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImportAll", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsRecursive)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isRecursive", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedElement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.ImportedMembership != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importOwningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs
index b4fcce4b9..13a3dbd18 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MembershipImportWriter" /> is to write an instance of <see cref="IMembershipImport" />
     /// to the XMI document
     /// </summary>
-    public static class MembershipImportWriter
+    public class MembershipImportWriter : XmiDataWriter<IMembershipImport>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MembershipImportWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MembershipImportWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MembershipImportWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MembershipImportWriter>.Instance : loggerFactory.CreateLogger<MembershipImportWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMembershipImport" /> object to its XML representation
         /// </summary>
@@ -49,160 +70,456 @@ public static class MembershipImportWriter
         /// <param name="poco">The <see cref="IMembershipImport" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMembershipImport poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MembershipImport");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsImportAll)
             {
                 xmlWriter.WriteAttributeString("isImportAll", "true");
             }
-            if (poco.IsRecursive)
-            {
-                xmlWriter.WriteAttributeString("isRecursive", "true");
-            }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsRecursive)
+            {
+                xmlWriter.WriteAttributeString("isRecursive", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.ImportedMembership != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importOwningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMembershipImport" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMembershipImport" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MembershipImport");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsImportAll)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImportAll", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsRecursive)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isRecursive", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedElement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.ImportedMembership != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importOwningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs
index a8638971e..c956384d0 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MembershipWriter" /> is to write an instance of <see cref="IMembership" />
     /// to the XMI document
     /// </summary>
-    public static class MembershipWriter
+    public class MembershipWriter : XmiDataWriter<IMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MembershipWriter>.Instance : loggerFactory.CreateLogger<MembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMembership" /> object to its XML representation
         /// </summary>
@@ -49,160 +70,456 @@ public static class MembershipWriter
         /// <param name="poco">The <see cref="IMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Membership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            if (!string.IsNullOrWhiteSpace(poco.MemberName))
-            {
-                xmlWriter.WriteAttributeString("memberName", poco.MemberName);
-            }
-            if (!string.IsNullOrWhiteSpace(poco.MemberShortName))
-            {
-                xmlWriter.WriteAttributeString("memberShortName", poco.MemberShortName);
-            }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.memberElementId))
                 {
                     xmlWriter.WriteAttributeString("memberElementId", poco.memberElementId);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.MemberName))
+            {
+                xmlWriter.WriteAttributeString("memberName", poco.MemberName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.MemberShortName))
+            {
+                xmlWriter.WriteAttributeString("memberShortName", poco.MemberShortName);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.MemberElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.MemberElement, "memberElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.MemberElement, "memberElement", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membershipOwningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Membership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.memberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "memberElementId", null, poco.memberElementId);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.MemberName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "memberName", null, poco.MemberName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.MemberShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "memberShortName", null, poco.MemberShortName);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.MemberElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.MemberElement, "memberElement", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membershipOwningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs
index 98ba6f942..e7cac3cbe 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MergeNodeWriter" /> is to write an instance of <see cref="IMergeNode" />
     /// to the XMI document
     /// </summary>
-    public static class MergeNodeWriter
+    public class MergeNodeWriter : XmiDataWriter<IMergeNode>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MergeNodeWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MergeNodeWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MergeNodeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MergeNodeWriter>.Instance : loggerFactory.CreateLogger<MergeNodeWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMergeNode" /> object to its XML representation
         /// </summary>
@@ -77,686 +98,2143 @@ public static class MergeNodeWriter
         /// <param name="poco">The <see cref="IMergeNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMergeNode poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MergeNode");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMergeNode" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMergeNode" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MergeNode");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs
index 3da79fb27..265003cde 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MetaclassWriter" /> is to write an instance of <see cref="IMetaclass" />
     /// to the XMI document
     /// </summary>
-    public static class MetaclassWriter
+    public class MetaclassWriter : XmiDataWriter<IMetaclass>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MetaclassWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MetaclassWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MetaclassWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MetaclassWriter>.Instance : loggerFactory.CreateLogger<MetaclassWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMetaclass" /> object to its XML representation
         /// </summary>
@@ -53,320 +74,973 @@ public static class MetaclassWriter
         /// <param name="poco">The <see cref="IMetaclass" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMetaclass poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Metaclass");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
-            {
-                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
-            }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
                     xmlWriter.WriteAttributeString("isConjugated", "true");
                 }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMetaclass" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMetaclass" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMetaclass poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Metaclass");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs
index 6d65b6bfb..372e4115a 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MetadataAccessExpressionWriter" /> is to write an instance of <see cref="IMetadataAccessExpression" />
     /// to the XMI document
     /// </summary>
-    public static class MetadataAccessExpressionWriter
+    public class MetadataAccessExpressionWriter : XmiDataWriter<IMetadataAccessExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MetadataAccessExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MetadataAccessExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MetadataAccessExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MetadataAccessExpressionWriter>.Instance : loggerFactory.CreateLogger<MetadataAccessExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMetadataAccessExpression" /> object to its XML representation
         /// </summary>
@@ -54,453 +75,1409 @@ public static class MetadataAccessExpressionWriter
         /// <param name="poco">The <see cref="IMetadataAccessExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataAccessExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.referencedElement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedElement, "referencedElement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedElement, "referencedElement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMetadataAccessExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMetadataAccessExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MetadataAccessExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.referencedElement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referencedElement, "referencedElement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs
index ed6ffa1c2..288a1aa45 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MetadataDefinitionWriter" /> is to write an instance of <see cref="IMetadataDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class MetadataDefinitionWriter
+    public class MetadataDefinitionWriter : XmiDataWriter<IMetadataDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MetadataDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MetadataDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MetadataDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MetadataDefinitionWriter>.Instance : loggerFactory.CreateLogger<MetadataDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMetadataDefinition" /> object to its XML representation
         /// </summary>
@@ -74,545 +95,1675 @@ public static class MetadataDefinitionWriter
         /// <param name="poco">The <see cref="IMetadataDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedSpecialization != null)
-                {
-                    foreach (var item in poco.ownedSpecialization)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMetadataDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMetadataDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MetadataDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs
index 40f101026..e24c527f6 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MetadataFeatureWriter" /> is to write an instance of <see cref="IMetadataFeature" />
     /// to the XMI document
     /// </summary>
-    public static class MetadataFeatureWriter
+    public class MetadataFeatureWriter : XmiDataWriter<IMetadataFeature>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MetadataFeatureWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MetadataFeatureWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MetadataFeatureWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MetadataFeatureWriter>.Instance : loggerFactory.CreateLogger<MetadataFeatureWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMetadataFeature" /> object to its XML representation
         /// </summary>
@@ -52,466 +73,1443 @@ public static class MetadataFeatureWriter
         /// <param name="poco">The <see cref="IMetadataFeature" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMetadataFeature poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataFeature");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.metaclass != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.metaclass, "metaclass", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.metaclass, "metaclass", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningAnnotatingRelationship != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMetadataFeature" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMetadataFeature" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MetadataFeature");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.annotatedElement != null)
+                {
+                    foreach (var item in poco.annotatedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.metaclass != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.metaclass, "metaclass", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs
index 7f6565ab1..81514aef9 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MetadataUsageWriter" /> is to write an instance of <see cref="IMetadataUsage" />
     /// to the XMI document
     /// </summary>
-    public static class MetadataUsageWriter
+    public class MetadataUsageWriter : XmiDataWriter<IMetadataUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MetadataUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MetadataUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MetadataUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MetadataUsageWriter>.Instance : loggerFactory.CreateLogger<MetadataUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMetadataUsage" /> object to its XML representation
         /// </summary>
@@ -78,715 +99,2241 @@ public static class MetadataUsageWriter
         /// <param name="poco">The <see cref="IMetadataUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.metadataDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.metadataDefinition, "metadataDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.metadataDefinition, "metadataDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedRendering != null)
-                {
-                    foreach (var item in poco.nestedRendering)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningAnnotatingRelationship != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMetadataUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMetadataUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MetadataUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.annotatedElement != null)
+                {
+                    foreach (var item in poco.annotatedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.metadataDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.metadataDefinition, "metadataDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs
index e3d09bafe..0e9820767 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MultiplicityRangeWriter" /> is to write an instance of <see cref="IMultiplicityRange" />
     /// to the XMI document
     /// </summary>
-    public static class MultiplicityRangeWriter
+    public class MultiplicityRangeWriter : XmiDataWriter<IMultiplicityRange>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MultiplicityRangeWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MultiplicityRangeWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MultiplicityRangeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MultiplicityRangeWriter>.Instance : loggerFactory.CreateLogger<MultiplicityRangeWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMultiplicityRange" /> object to its XML representation
         /// </summary>
@@ -53,452 +74,1399 @@ public static class MultiplicityRangeWriter
         /// <param name="poco">The <see cref="IMultiplicityRange" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MultiplicityRange");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.bound != null)
                 {
                     foreach (var item in poco.bound)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "bound", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "bound", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.lowerBound != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.lowerBound, "lowerBound", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.lowerBound, "lowerBound", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.upperBound != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.upperBound, "upperBound", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.upperBound, "upperBound", elementOriginMap, currentFileUri);
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMultiplicityRange" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMultiplicityRange" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MultiplicityRange");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.bound != null)
+                {
+                    foreach (var item in poco.bound)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "bound", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.lowerBound != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.lowerBound, "lowerBound", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.upperBound != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.upperBound, "upperBound", elementOriginMap, currentFileUri);
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs
index f446cd931..502ade197 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -42,8 +46,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="MultiplicityWriter" /> is to write an instance of <see cref="IMultiplicity" />
     /// to the XMI document
     /// </summary>
-    public static class MultiplicityWriter
+    public class MultiplicityWriter : XmiDataWriter<IMultiplicity>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<MultiplicityWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MultiplicityWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public MultiplicityWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<MultiplicityWriter>.Instance : loggerFactory.CreateLogger<MultiplicityWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IMultiplicity" /> object to its XML representation
         /// </summary>
@@ -51,437 +72,1345 @@ public static class MultiplicityWriter
         /// <param name="poco">The <see cref="IMultiplicity" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IMultiplicity poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Multiplicity");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
-                if (poco.owningType != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
-                }
-                if (poco.textualRepresentation != null)
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IMultiplicity" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IMultiplicity" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Multiplicity");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs
index 29847d540..2ce578c56 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="NamespaceExposeWriter" /> is to write an instance of <see cref="INamespaceExpose" />
     /// to the XMI document
     /// </summary>
-    public static class NamespaceExposeWriter
+    public class NamespaceExposeWriter : XmiDataWriter<INamespaceExpose>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<NamespaceExposeWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NamespaceExposeWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public NamespaceExposeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<NamespaceExposeWriter>.Instance : loggerFactory.CreateLogger<NamespaceExposeWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="INamespaceExpose" /> object to its XML representation
         /// </summary>
@@ -50,160 +71,456 @@ public static class NamespaceExposeWriter
         /// <param name="poco">The <see cref="INamespaceExpose" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, INamespaceExpose poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:NamespaceExpose");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsImportAll)
             {
                 xmlWriter.WriteAttributeString("isImportAll", "true");
             }
-            if (poco.IsRecursive)
-            {
-                xmlWriter.WriteAttributeString("isRecursive", "true");
-            }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsRecursive)
+            {
+                xmlWriter.WriteAttributeString("isRecursive", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.ImportedNamespace != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importOwningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="INamespaceExpose" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="INamespaceExpose" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceExpose poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:NamespaceExpose");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsImportAll)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImportAll", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsRecursive)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isRecursive", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedElement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.ImportedNamespace != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importOwningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs
index a7ce05c96..1e29eacd5 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="NamespaceImportWriter" /> is to write an instance of <see cref="INamespaceImport" />
     /// to the XMI document
     /// </summary>
-    public static class NamespaceImportWriter
+    public class NamespaceImportWriter : XmiDataWriter<INamespaceImport>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<NamespaceImportWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NamespaceImportWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public NamespaceImportWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<NamespaceImportWriter>.Instance : loggerFactory.CreateLogger<NamespaceImportWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="INamespaceImport" /> object to its XML representation
         /// </summary>
@@ -49,160 +70,456 @@ public static class NamespaceImportWriter
         /// <param name="poco">The <see cref="INamespaceImport" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, INamespaceImport poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:NamespaceImport");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsImportAll)
             {
                 xmlWriter.WriteAttributeString("isImportAll", "true");
             }
-            if (poco.IsRecursive)
-            {
-                xmlWriter.WriteAttributeString("isRecursive", "true");
-            }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsRecursive)
+            {
+                xmlWriter.WriteAttributeString("isRecursive", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.ImportedNamespace != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importOwningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="INamespaceImport" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="INamespaceImport" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:NamespaceImport");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsImportAll)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImportAll", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsRecursive)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isRecursive", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedElement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.ImportedNamespace != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importOwningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs
index 8b46a3b25..69e9082ab 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -39,8 +43,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="NamespaceWriter" /> is to write an instance of <see cref="INamespace" />
     /// to the XMI document
     /// </summary>
-    public static class NamespaceWriter
+    public class NamespaceWriter : XmiDataWriter<INamespace>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<NamespaceWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NamespaceWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public NamespaceWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<NamespaceWriter>.Instance : loggerFactory.CreateLogger<NamespaceWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="INamespace" /> object to its XML representation
         /// </summary>
@@ -48,159 +69,464 @@ public static class NamespaceWriter
         /// <param name="poco">The <see cref="INamespace" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, INamespace poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, INamespace poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Namespace");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="INamespace" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="INamespace" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, INamespace poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Namespace");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs
index f1b08eed8..b6e3115ff 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="NullExpressionWriter" /> is to write an instance of <see cref="INullExpression" />
     /// to the XMI document
     /// </summary>
-    public static class NullExpressionWriter
+    public class NullExpressionWriter : XmiDataWriter<INullExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<NullExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NullExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public NullExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<NullExpressionWriter>.Instance : loggerFactory.CreateLogger<NullExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="INullExpression" /> object to its XML representation
         /// </summary>
@@ -54,449 +75,1393 @@ public static class NullExpressionWriter
         /// <param name="poco">The <see cref="INullExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, INullExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, INullExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:NullExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="INullExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="INullExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:NullExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs
index dcda4dcbe..de4c573b5 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ObjectiveMembershipWriter" /> is to write an instance of <see cref="IObjectiveMembership" />
     /// to the XMI document
     /// </summary>
-    public static class ObjectiveMembershipWriter
+    public class ObjectiveMembershipWriter : XmiDataWriter<IObjectiveMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ObjectiveMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ObjectiveMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ObjectiveMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ObjectiveMembershipWriter>.Instance : loggerFactory.CreateLogger<ObjectiveMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IObjectiveMembership" /> object to its XML representation
         /// </summary>
@@ -53,160 +74,474 @@ public static class ObjectiveMembershipWriter
         /// <param name="poco">The <see cref="IObjectiveMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IObjectiveMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ObjectiveMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedObjectiveRequirement != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedObjectiveRequirement, "ownedObjectiveRequirement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IObjectiveMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IObjectiveMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ObjectiveMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedObjectiveRequirement != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedObjectiveRequirement, "ownedObjectiveRequirement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedObjectiveRequirement, "ownedObjectiveRequirement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs
index 254920928..b7ba3dcb3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="OccurrenceDefinitionWriter" /> is to write an instance of <see cref="IOccurrenceDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class OccurrenceDefinitionWriter
+    public class OccurrenceDefinitionWriter : XmiDataWriter<IOccurrenceDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<OccurrenceDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OccurrenceDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public OccurrenceDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<OccurrenceDefinitionWriter>.Instance : loggerFactory.CreateLogger<OccurrenceDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IOccurrenceDefinition" /> object to its XML representation
         /// </summary>
@@ -74,545 +95,1675 @@ public static class OccurrenceDefinitionWriter
         /// <param name="poco">The <see cref="IOccurrenceDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OccurrenceDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedSpecialization != null)
-                {
-                    foreach (var item in poco.ownedSpecialization)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IOccurrenceDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IOccurrenceDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:OccurrenceDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs
index 0fe2477c0..945b7edaf 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -67,8 +71,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="OccurrenceUsageWriter" /> is to write an instance of <see cref="IOccurrenceUsage" />
     /// to the XMI document
     /// </summary>
-    public static class OccurrenceUsageWriter
+    public class OccurrenceUsageWriter : XmiDataWriter<IOccurrenceUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<OccurrenceUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OccurrenceUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public OccurrenceUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<OccurrenceUsageWriter>.Instance : loggerFactory.CreateLogger<OccurrenceUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IOccurrenceUsage" /> object to its XML representation
         /// </summary>
@@ -76,679 +97,2121 @@ public static class OccurrenceUsageWriter
         /// <param name="poco">The <see cref="IOccurrenceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OccurrenceUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IOccurrenceUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IOccurrenceUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:OccurrenceUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs
index ab6f7364b..65ac9b588 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="OperatorExpressionWriter" /> is to write an instance of <see cref="IOperatorExpression" />
     /// to the XMI document
     /// </summary>
-    public static class OperatorExpressionWriter
+    public class OperatorExpressionWriter : XmiDataWriter<IOperatorExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<OperatorExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OperatorExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public OperatorExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<OperatorExpressionWriter>.Instance : loggerFactory.CreateLogger<OperatorExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IOperatorExpression" /> object to its XML representation
         /// </summary>
@@ -54,464 +75,1441 @@ public static class OperatorExpressionWriter
         /// <param name="poco">The <see cref="IOperatorExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IOperatorExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OperatorExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
-            {
-                xmlWriter.WriteAttributeString("operator", poco.Operator);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                xmlWriter.WriteAttributeString("operator", poco.Operator);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.instantiatedType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedTypeFeaturing != null)
-                {
-                    foreach (var item in poco.ownedTypeFeaturing)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IOperatorExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IOperatorExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:OperatorExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.instantiatedType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs
index e15b2e27d..f2a07ad61 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="OwningMembershipWriter" /> is to write an instance of <see cref="IOwningMembership" />
     /// to the XMI document
     /// </summary>
-    public static class OwningMembershipWriter
+    public class OwningMembershipWriter : XmiDataWriter<IOwningMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<OwningMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OwningMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public OwningMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<OwningMembershipWriter>.Instance : loggerFactory.CreateLogger<OwningMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IOwningMembership" /> object to its XML representation
         /// </summary>
@@ -49,160 +70,474 @@ public static class OwningMembershipWriter
         /// <param name="poco">The <see cref="IOwningMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IOwningMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OwningMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membershipOwningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMemberElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberElement, "ownedMemberElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IOwningMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IOwningMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:OwningMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membershipOwningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMemberElement != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberElement, "ownedMemberElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedMemberElement, "ownedMemberElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs
index 701dfcf99..fc3cb8be1 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="PackageWriter" /> is to write an instance of <see cref="IPackage" />
     /// to the XMI document
     /// </summary>
-    public static class PackageWriter
+    public class PackageWriter : XmiDataWriter<IPackage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<PackageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PackageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public PackageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<PackageWriter>.Instance : loggerFactory.CreateLogger<PackageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IPackage" /> object to its XML representation
         /// </summary>
@@ -50,166 +71,486 @@ public static class PackageWriter
         /// <param name="poco">The <see cref="IPackage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IPackage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPackage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Package");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.filterCondition != null)
+                {
+                    foreach (var item in poco.filterCondition)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "filterCondition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IPackage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPackage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPackage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Package");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.filterCondition != null)
                 {
                     foreach (var item in poco.filterCondition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "filterCondition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "filterCondition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs
index 31547ca90..b1d3bee3b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ParameterMembershipWriter" /> is to write an instance of <see cref="IParameterMembership" />
     /// to the XMI document
     /// </summary>
-    public static class ParameterMembershipWriter
+    public class ParameterMembershipWriter : XmiDataWriter<IParameterMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ParameterMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ParameterMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ParameterMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ParameterMembershipWriter>.Instance : loggerFactory.CreateLogger<ParameterMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IParameterMembership" /> object to its XML representation
         /// </summary>
@@ -52,160 +73,474 @@ public static class ParameterMembershipWriter
         /// <param name="poco">The <see cref="IParameterMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IParameterMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IParameterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ParameterMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMemberParameter != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IParameterMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IParameterMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ParameterMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMemberParameter != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs
index 204e8a767..391847527 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -64,8 +68,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="PartDefinitionWriter" /> is to write an instance of <see cref="IPartDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class PartDefinitionWriter
+    public class PartDefinitionWriter : XmiDataWriter<IPartDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<PartDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PartDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public PartDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<PartDefinitionWriter>.Instance : loggerFactory.CreateLogger<PartDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IPartDefinition" /> object to its XML representation
         /// </summary>
@@ -73,545 +94,1675 @@ public static class PartDefinitionWriter
         /// <param name="poco">The <see cref="IPartDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IPartDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PartDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedSpecialization != null)
-                {
-                    foreach (var item in poco.ownedSpecialization)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IPartDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPartDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PartDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs
index 26826aff2..55787e53f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="PartUsageWriter" /> is to write an instance of <see cref="IPartUsage" />
     /// to the XMI document
     /// </summary>
-    public static class PartUsageWriter
+    public class PartUsageWriter : XmiDataWriter<IPartUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<PartUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PartUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public PartUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<PartUsageWriter>.Instance : loggerFactory.CreateLogger<PartUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IPartUsage" /> object to its XML representation
         /// </summary>
@@ -77,693 +98,2165 @@ public static class PartUsageWriter
         /// <param name="poco">The <see cref="IPartUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IPartUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PartUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedTransition != null)
-                {
-                    foreach (var item in poco.nestedTransition)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.partDefinition != null)
                 {
                     foreach (var item in poco.partDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IPartUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPartUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PartUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.partDefinition != null)
+                {
+                    foreach (var item in poco.partDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs
index 0cf7be68e..95243ec2c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="PayloadFeatureWriter" /> is to write an instance of <see cref="IPayloadFeature" />
     /// to the XMI document
     /// </summary>
-    public static class PayloadFeatureWriter
+    public class PayloadFeatureWriter : XmiDataWriter<IPayloadFeature>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<PayloadFeatureWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PayloadFeatureWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public PayloadFeatureWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<PayloadFeatureWriter>.Instance : loggerFactory.CreateLogger<PayloadFeatureWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IPayloadFeature" /> object to its XML representation
         /// </summary>
@@ -52,437 +73,1345 @@ public static class PayloadFeatureWriter
         /// <param name="poco">The <see cref="IPayloadFeature" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IPayloadFeature poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PayloadFeature");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
-                if (poco.owningType != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
-                }
-                if (poco.textualRepresentation != null)
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IPayloadFeature" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPayloadFeature" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PayloadFeature");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs
index 75e64cf0c..d19bbf237 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="PerformActionUsageWriter" /> is to write an instance of <see cref="IPerformActionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class PerformActionUsageWriter
+    public class PerformActionUsageWriter : XmiDataWriter<IPerformActionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<PerformActionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PerformActionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public PerformActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<PerformActionUsageWriter>.Instance : loggerFactory.CreateLogger<PerformActionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IPerformActionUsage" /> object to its XML representation
         /// </summary>
@@ -77,690 +98,2159 @@ public static class PerformActionUsageWriter
         /// <param name="poco">The <see cref="IPerformActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PerformActionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.performedAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.performedAction, "performedAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.performedAction, "performedAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IPerformActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPerformActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PerformActionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.performedAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.performedAction, "performedAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs
index 8010e57f5..341065e52 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="PortConjugationWriter" /> is to write an instance of <see cref="IPortConjugation" />
     /// to the XMI document
     /// </summary>
-    public static class PortConjugationWriter
+    public class PortConjugationWriter : XmiDataWriter<IPortConjugation>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<PortConjugationWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PortConjugationWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public PortConjugationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<PortConjugationWriter>.Instance : loggerFactory.CreateLogger<PortConjugationWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IPortConjugation" /> object to its XML representation
         /// </summary>
@@ -50,151 +71,426 @@ public static class PortConjugationWriter
         /// <param name="poco">The <see cref="IPortConjugation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IPortConjugation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PortConjugation");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.conjugatedPortDefinition != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.ConjugatedType != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OriginalPortDefinition != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OriginalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OriginalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IPortConjugation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPortConjugation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PortConjugation");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.conjugatedPortDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.ConjugatedType != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OriginalPortDefinition != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OriginalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs
index 483078500..24fe0234d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="PortDefinitionWriter" /> is to write an instance of <see cref="IPortDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class PortDefinitionWriter
+    public class PortDefinitionWriter : XmiDataWriter<IPortDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<PortDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PortDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public PortDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<PortDefinitionWriter>.Instance : loggerFactory.CreateLogger<PortDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IPortDefinition" /> object to its XML representation
         /// </summary>
@@ -74,549 +95,1691 @@ public static class PortDefinitionWriter
         /// <param name="poco">The <see cref="IPortDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IPortDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PortDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (poco.conjugatedPortDefinition != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
             if (includeDerivedProperties)
             {
-                if (poco.conjugatedPortDefinition != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
-                }
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedSpecialization != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IPortDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPortDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PortDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.conjugatedPortDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs
index 15279d011..cd809ae0d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -67,8 +71,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="PortUsageWriter" /> is to write an instance of <see cref="IPortUsage" />
     /// to the XMI document
     /// </summary>
-    public static class PortUsageWriter
+    public class PortUsageWriter : XmiDataWriter<IPortUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<PortUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PortUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public PortUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<PortUsageWriter>.Instance : loggerFactory.CreateLogger<PortUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IPortUsage" /> object to its XML representation
         /// </summary>
@@ -76,679 +97,2121 @@ public static class PortUsageWriter
         /// <param name="poco">The <see cref="IPortUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IPortUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PortUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.portDefinition != null)
                 {
                     foreach (var item in poco.portDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "portDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "portDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IPortUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPortUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PortUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.portDefinition != null)
+                {
+                    foreach (var item in poco.portDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "portDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs
index 7fc20e2d3..de9dca975 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="PredicateWriter" /> is to write an instance of <see cref="IPredicate" />
     /// to the XMI document
     /// </summary>
-    public static class PredicateWriter
+    public class PredicateWriter : XmiDataWriter<IPredicate>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<PredicateWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PredicateWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public PredicateWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<PredicateWriter>.Instance : loggerFactory.CreateLogger<PredicateWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IPredicate" /> object to its XML representation
         /// </summary>
@@ -53,342 +74,1049 @@ public static class PredicateWriter
         /// <param name="poco">The <see cref="IPredicate" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IPredicate poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Predicate");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
-            {
-                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
-            }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
                     xmlWriter.WriteAttributeString("isConjugated", "true");
                 }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IPredicate" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IPredicate" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Predicate");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs
index 0788c4562..754325343 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="RedefinitionWriter" /> is to write an instance of <see cref="IRedefinition" />
     /// to the XMI document
     /// </summary>
-    public static class RedefinitionWriter
+    public class RedefinitionWriter : XmiDataWriter<IRedefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<RedefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RedefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public RedefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<RedefinitionWriter>.Instance : loggerFactory.CreateLogger<RedefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IRedefinition" /> object to its XML representation
         /// </summary>
@@ -50,151 +71,426 @@ public static class RedefinitionWriter
         /// <param name="poco">The <see cref="IRedefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IRedefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRedefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Redefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeature != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
+
             if (poco.RedefinedFeature != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.RedefinedFeature, "redefinedFeature", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.RedefinedFeature, "redefinedFeature", elementOriginMap, currentFileUri);
             }
+
             if (poco.RedefiningFeature != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.RedefiningFeature, "redefiningFeature", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.RedefiningFeature, "redefiningFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IRedefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRedefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRedefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Redefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.RedefinedFeature != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.RedefinedFeature, "redefinedFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.RedefiningFeature != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.RedefiningFeature, "redefiningFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs
index cf6073f51..e10dca1da 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ReferenceSubsettingWriter" /> is to write an instance of <see cref="IReferenceSubsetting" />
     /// to the XMI document
     /// </summary>
-    public static class ReferenceSubsettingWriter
+    public class ReferenceSubsettingWriter : XmiDataWriter<IReferenceSubsetting>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ReferenceSubsettingWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReferenceSubsettingWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ReferenceSubsettingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ReferenceSubsettingWriter>.Instance : loggerFactory.CreateLogger<ReferenceSubsettingWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IReferenceSubsetting" /> object to its XML representation
         /// </summary>
@@ -50,147 +71,416 @@ public static class ReferenceSubsettingWriter
         /// <param name="poco">The <see cref="IReferenceSubsetting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ReferenceSubsetting");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
+
             if (poco.ReferencedFeature != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ReferencedFeature, "referencedFeature", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ReferencedFeature, "referencedFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.referencingFeature != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencingFeature, "referencingFeature", elementOriginMap, currentFileUri);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IReferenceSubsetting" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IReferenceSubsetting" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceSubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ReferenceSubsetting");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.ReferencedFeature != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ReferencedFeature, "referencedFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.referencingFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencingFeature, "referencingFeature", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referencingFeature, "referencingFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs
index 28545e9e6..c39b92fa7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ReferenceUsageWriter" /> is to write an instance of <see cref="IReferenceUsage" />
     /// to the XMI document
     /// </summary>
-    public static class ReferenceUsageWriter
+    public class ReferenceUsageWriter : XmiDataWriter<IReferenceUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ReferenceUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReferenceUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ReferenceUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ReferenceUsageWriter>.Instance : loggerFactory.CreateLogger<ReferenceUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IReferenceUsage" /> object to its XML representation
         /// </summary>
@@ -74,670 +95,2091 @@ public static class ReferenceUsageWriter
         /// <param name="poco">The <see cref="IReferenceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IReferenceUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ReferenceUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.definition != null)
                 {
                     foreach (var item in poco.definition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUseCase != null)
-                {
-                    foreach (var item in poco.nestedUseCase)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IReferenceUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IReferenceUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ReferenceUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.definition != null)
+                {
+                    foreach (var item in poco.definition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs
index 15ac6a785..e65e0aa79 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -64,8 +68,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="RenderingDefinitionWriter" /> is to write an instance of <see cref="IRenderingDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class RenderingDefinitionWriter
+    public class RenderingDefinitionWriter : XmiDataWriter<IRenderingDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<RenderingDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RenderingDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public RenderingDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<RenderingDefinitionWriter>.Instance : loggerFactory.CreateLogger<RenderingDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IRenderingDefinition" /> object to its XML representation
         /// </summary>
@@ -73,552 +94,1697 @@ public static class RenderingDefinitionWriter
         /// <param name="poco">The <see cref="IRenderingDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IRenderingDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RenderingDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedSpecialization != null)
-                {
-                    foreach (var item in poco.ownedSpecialization)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.rendering != null)
                 {
                     foreach (var item in poco.rendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "rendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "rendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IRenderingDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRenderingDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RenderingDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.rendering != null)
+                {
+                    foreach (var item in poco.rendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "rendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs
index 75c63dad2..760e884b2 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="RenderingUsageWriter" /> is to write an instance of <see cref="IRenderingUsage" />
     /// to the XMI document
     /// </summary>
-    public static class RenderingUsageWriter
+    public class RenderingUsageWriter : XmiDataWriter<IRenderingUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<RenderingUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RenderingUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public RenderingUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<RenderingUsageWriter>.Instance : loggerFactory.CreateLogger<RenderingUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IRenderingUsage" /> object to its XML representation
         /// </summary>
@@ -77,690 +98,2159 @@ public static class RenderingUsageWriter
         /// <param name="poco">The <see cref="IRenderingUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IRenderingUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RenderingUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedTransition != null)
-                {
-                    foreach (var item in poco.nestedTransition)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.renderingDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.renderingDefinition, "renderingDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.renderingDefinition, "renderingDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IRenderingUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRenderingUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RenderingUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.renderingDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.renderingDefinition, "renderingDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs
index 3539e4970..df4b63b0f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.Requirements;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="RequirementConstraintMembershipWriter" /> is to write an instance of <see cref="IRequirementConstraintMembership" />
     /// to the XMI document
     /// </summary>
-    public static class RequirementConstraintMembershipWriter
+    public class RequirementConstraintMembershipWriter : XmiDataWriter<IRequirementConstraintMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<RequirementConstraintMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequirementConstraintMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public RequirementConstraintMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<RequirementConstraintMembershipWriter>.Instance : loggerFactory.CreateLogger<RequirementConstraintMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IRequirementConstraintMembership" /> object to its XML representation
         /// </summary>
@@ -54,165 +75,494 @@ public static class RequirementConstraintMembershipWriter
         /// <param name="poco">The <see cref="IRequirementConstraintMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IRequirementConstraintMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementConstraintMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConstraint, "ownedConstraint", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.referencedConstraint != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedConstraint, "referencedConstraint", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IRequirementConstraintMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRequirementConstraintMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstraintMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RequirementConstraintMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConstraint, "ownedConstraint", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConstraint, "ownedConstraint", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.referencedConstraint != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedConstraint, "referencedConstraint", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referencedConstraint, "referencedConstraint", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs
index 1cd9cbb28..191fe7312 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="RequirementDefinitionWriter" /> is to write an instance of <see cref="IRequirementDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class RequirementDefinitionWriter
+    public class RequirementDefinitionWriter : XmiDataWriter<IRequirementDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<RequirementDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequirementDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public RequirementDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<RequirementDefinitionWriter>.Instance : loggerFactory.CreateLogger<RequirementDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IRequirementDefinition" /> object to its XML representation
         /// </summary>
@@ -75,610 +96,1893 @@ public static class RequirementDefinitionWriter
         /// <param name="poco">The <see cref="IRequirementDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IRequirementDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
-            if (poco.IsVariation)
-            {
-                xmlWriter.WriteAttributeString("isVariation", "true");
-            }
-            if (!string.IsNullOrWhiteSpace(poco.ReqId))
-            {
-                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
-                if (poco.text != null && poco.text.Count > 0)
-                {
-                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (poco.text != null && poco.text.Count > 0)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedMetadata != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IRequirementDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRequirementDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RequirementDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "text", null, string.Join(" ", poco.text));
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs
index b7bb5b09b..6ca94647d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="RequirementUsageWriter" /> is to write an instance of <see cref="IRequirementUsage" />
     /// to the XMI document
     /// </summary>
-    public static class RequirementUsageWriter
+    public class RequirementUsageWriter : XmiDataWriter<IRequirementUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<RequirementUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequirementUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public RequirementUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<RequirementUsageWriter>.Instance : loggerFactory.CreateLogger<RequirementUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IRequirementUsage" /> object to its XML representation
         /// </summary>
@@ -78,734 +99,2311 @@ public static class RequirementUsageWriter
         /// <param name="poco">The <see cref="IRequirementUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IRequirementUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
-            if (!string.IsNullOrWhiteSpace(poco.ReqId))
-            {
-                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
-                if (poco.text != null && poco.text.Count > 0)
-                {
-                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (poco.text != null && poco.text.Count > 0)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedOccurrence != null)
-                {
-                    foreach (var item in poco.nestedOccurrence)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.requirementDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IRequirementUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRequirementUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RequirementUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "text", null, string.Join(" ", poco.text));
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.requirementDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs
index 3f0636cc8..52c9ec676 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.Requirements;
@@ -46,8 +50,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="RequirementVerificationMembershipWriter" /> is to write an instance of <see cref="IRequirementVerificationMembership" />
     /// to the XMI document
     /// </summary>
-    public static class RequirementVerificationMembershipWriter
+    public class RequirementVerificationMembershipWriter : XmiDataWriter<IRequirementVerificationMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<RequirementVerificationMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequirementVerificationMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public RequirementVerificationMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<RequirementVerificationMembershipWriter>.Instance : loggerFactory.CreateLogger<RequirementVerificationMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IRequirementVerificationMembership" /> object to its XML representation
         /// </summary>
@@ -55,165 +76,494 @@ public static class RequirementVerificationMembershipWriter
         /// <param name="poco">The <see cref="IRequirementVerificationMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IRequirementVerificationMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementVerificationMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedRequirement, "ownedRequirement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.verifiedRequirement != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.verifiedRequirement, "verifiedRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IRequirementVerificationMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IRequirementVerificationMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificationMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RequirementVerificationMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedRequirement, "ownedRequirement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedRequirement, "ownedRequirement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.verifiedRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.verifiedRequirement, "verifiedRequirement", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.verifiedRequirement, "verifiedRequirement", elementOriginMap, currentFileUri);
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs
index fcef3ec9e..bfdd63f74 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ResultExpressionMembershipWriter" /> is to write an instance of <see cref="IResultExpressionMembership" />
     /// to the XMI document
     /// </summary>
-    public static class ResultExpressionMembershipWriter
+    public class ResultExpressionMembershipWriter : XmiDataWriter<IResultExpressionMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ResultExpressionMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ResultExpressionMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ResultExpressionMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ResultExpressionMembershipWriter>.Instance : loggerFactory.CreateLogger<ResultExpressionMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IResultExpressionMembership" /> object to its XML representation
         /// </summary>
@@ -52,160 +73,474 @@ public static class ResultExpressionMembershipWriter
         /// <param name="poco">The <see cref="IResultExpressionMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IResultExpressionMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ResultExpressionMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedResultExpression != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedResultExpression, "ownedResultExpression", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IResultExpressionMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IResultExpressionMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ResultExpressionMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedResultExpression != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedResultExpression, "ownedResultExpression", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedResultExpression, "ownedResultExpression", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs
index 42e73adda..17d969c2b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ReturnParameterMembershipWriter" /> is to write an instance of <see cref="IReturnParameterMembership" />
     /// to the XMI document
     /// </summary>
-    public static class ReturnParameterMembershipWriter
+    public class ReturnParameterMembershipWriter : XmiDataWriter<IReturnParameterMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ReturnParameterMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReturnParameterMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ReturnParameterMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ReturnParameterMembershipWriter>.Instance : loggerFactory.CreateLogger<ReturnParameterMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IReturnParameterMembership" /> object to its XML representation
         /// </summary>
@@ -53,160 +74,474 @@ public static class ReturnParameterMembershipWriter
         /// <param name="poco">The <see cref="IReturnParameterMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IReturnParameterMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ReturnParameterMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMemberParameter != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IReturnParameterMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IReturnParameterMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ReturnParameterMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMemberParameter != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs
index ad3f4abe7..1266b299e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SatisfyRequirementUsageWriter" /> is to write an instance of <see cref="ISatisfyRequirementUsage" />
     /// to the XMI document
     /// </summary>
-    public static class SatisfyRequirementUsageWriter
+    public class SatisfyRequirementUsageWriter : XmiDataWriter<ISatisfyRequirementUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SatisfyRequirementUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SatisfyRequirementUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SatisfyRequirementUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SatisfyRequirementUsageWriter>.Instance : loggerFactory.CreateLogger<SatisfyRequirementUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISatisfyRequirementUsage" /> object to its XML representation
         /// </summary>
@@ -78,746 +99,2353 @@ public static class SatisfyRequirementUsageWriter
         /// <param name="poco">The <see cref="ISatisfyRequirementUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SatisfyRequirementUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsNegated)
             {
                 xmlWriter.WriteAttributeString("isNegated", "true");
             }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
-            if (!string.IsNullOrWhiteSpace(poco.ReqId))
-            {
-                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
-                if (poco.text != null && poco.text.Count > 0)
-                {
-                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (poco.text != null && poco.text.Count > 0)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedOccurrence != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.requirementDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.satisfiedRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.satisfiedRequirement, "satisfiedRequirement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.satisfiedRequirement, "satisfiedRequirement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.satisfyingFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.satisfyingFeature, "satisfyingFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.satisfyingFeature, "satisfyingFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISatisfyRequirementUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISatisfyRequirementUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SatisfyRequirementUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsNegated)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isNegated", null, "true");
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "text", null, string.Join(" ", poco.text));
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.requirementDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.satisfiedRequirement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.satisfiedRequirement, "satisfiedRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.satisfyingFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.satisfyingFeature, "satisfyingFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs
index a387ee3f0..384afb909 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SelectExpressionWriter" /> is to write an instance of <see cref="ISelectExpression" />
     /// to the XMI document
     /// </summary>
-    public static class SelectExpressionWriter
+    public class SelectExpressionWriter : XmiDataWriter<ISelectExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SelectExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SelectExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SelectExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SelectExpressionWriter>.Instance : loggerFactory.CreateLogger<SelectExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISelectExpression" /> object to its XML representation
         /// </summary>
@@ -54,464 +75,1441 @@ public static class SelectExpressionWriter
         /// <param name="poco">The <see cref="ISelectExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISelectExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SelectExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
-            {
-                xmlWriter.WriteAttributeString("operator", poco.Operator);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                xmlWriter.WriteAttributeString("operator", poco.Operator);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.instantiatedType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedTypeFeaturing != null)
-                {
-                    foreach (var item in poco.ownedTypeFeaturing)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISelectExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISelectExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SelectExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.instantiatedType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs
index 48afdd852..a742c51bb 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SendActionUsageWriter" /> is to write an instance of <see cref="ISendActionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class SendActionUsageWriter
+    public class SendActionUsageWriter : XmiDataWriter<ISendActionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SendActionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SendActionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SendActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SendActionUsageWriter>.Instance : loggerFactory.CreateLogger<SendActionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISendActionUsage" /> object to its XML representation
         /// </summary>
@@ -78,698 +99,2191 @@ public static class SendActionUsageWriter
         /// <param name="poco">The <see cref="ISendActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISendActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SendActionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.receiverArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.senderArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.senderArgument, "senderArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.senderArgument, "senderArgument", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISendActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISendActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SendActionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.receiverArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.senderArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.senderArgument, "senderArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs
index 6bc394304..1c8d77470 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SpecializationWriter" /> is to write an instance of <see cref="ISpecialization" />
     /// to the XMI document
     /// </summary>
-    public static class SpecializationWriter
+    public class SpecializationWriter : XmiDataWriter<ISpecialization>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SpecializationWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SpecializationWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SpecializationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SpecializationWriter>.Instance : loggerFactory.CreateLogger<SpecializationWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISpecialization" /> object to its XML representation
         /// </summary>
@@ -49,151 +70,426 @@ public static class SpecializationWriter
         /// <param name="poco">The <see cref="ISpecialization" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISpecialization poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISpecialization poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Specialization");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.General != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.General, "general", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.General, "general", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.Specific != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Specific, "specific", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Specific, "specific", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISpecialization" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISpecialization" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISpecialization poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Specialization");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.General != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.General, "general", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.Specific != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.Specific, "specific", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs
index fde2a7bc7..6040a2567 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="StakeholderMembershipWriter" /> is to write an instance of <see cref="IStakeholderMembership" />
     /// to the XMI document
     /// </summary>
-    public static class StakeholderMembershipWriter
+    public class StakeholderMembershipWriter : XmiDataWriter<IStakeholderMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<StakeholderMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StakeholderMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public StakeholderMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<StakeholderMembershipWriter>.Instance : loggerFactory.CreateLogger<StakeholderMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IStakeholderMembership" /> object to its XML representation
         /// </summary>
@@ -54,160 +75,474 @@ public static class StakeholderMembershipWriter
         /// <param name="poco">The <see cref="IStakeholderMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IStakeholderMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StakeholderMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedStakeholderParameter != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedStakeholderParameter, "ownedStakeholderParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IStakeholderMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStakeholderMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:StakeholderMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedStakeholderParameter != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedStakeholderParameter, "ownedStakeholderParameter", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedStakeholderParameter, "ownedStakeholderParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs
index aa99a726a..43acc5795 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="StateDefinitionWriter" /> is to write an instance of <see cref="IStateDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class StateDefinitionWriter
+    public class StateDefinitionWriter : XmiDataWriter<IStateDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<StateDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StateDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public StateDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<StateDefinitionWriter>.Instance : loggerFactory.CreateLogger<StateDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IStateDefinition" /> object to its XML representation
         /// </summary>
@@ -74,582 +95,1799 @@ public static class StateDefinitionWriter
         /// <param name="poco">The <see cref="IStateDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IStateDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StateDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsParallel)
             {
                 xmlWriter.WriteAttributeString("isParallel", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.doAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.entryAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.exitAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedRendering != null)
-                {
-                    foreach (var item in poco.ownedRendering)
-                    {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
-                    }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.state != null)
                 {
                     foreach (var item in poco.state)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "state", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "state", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IStateDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStateDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:StateDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsParallel)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isParallel", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.doAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.entryAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.exitAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.state != null)
+                {
+                    foreach (var item in poco.state)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "state", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs
index 4e5f5dc4e..8e982a5b0 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.States;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="StateSubactionMembershipWriter" /> is to write an instance of <see cref="IStateSubactionMembership" />
     /// to the XMI document
     /// </summary>
-    public static class StateSubactionMembershipWriter
+    public class StateSubactionMembershipWriter : XmiDataWriter<IStateSubactionMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<StateSubactionMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StateSubactionMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public StateSubactionMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<StateSubactionMembershipWriter>.Instance : loggerFactory.CreateLogger<StateSubactionMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IStateSubactionMembership" /> object to its XML representation
         /// </summary>
@@ -54,161 +75,478 @@ public static class StateSubactionMembershipWriter
         /// <param name="poco">The <see cref="IStateSubactionMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IStateSubactionMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StateSubactionMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.action, "action", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IStateSubactionMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStateSubactionMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:StateSubactionMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.action != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.action, "action", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.action, "action", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs
index 9700ad2dd..f22d0129b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -68,8 +72,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="StateUsageWriter" /> is to write an instance of <see cref="IStateUsage" />
     /// to the XMI document
     /// </summary>
-    public static class StateUsageWriter
+    public class StateUsageWriter : XmiDataWriter<IStateUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<StateUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StateUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public StateUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<StateUsageWriter>.Instance : loggerFactory.CreateLogger<StateUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IStateUsage" /> object to its XML representation
         /// </summary>
@@ -77,702 +98,2201 @@ public static class StateUsageWriter
         /// <param name="poco">The <see cref="IStateUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IStateUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStateUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StateUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsParallel)
             {
                 xmlWriter.WriteAttributeString("isParallel", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.doAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.entryAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.exitAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedState != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.stateDefinition != null)
                 {
                     foreach (var item in poco.stateDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stateDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stateDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IStateUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStateUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:StateUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsParallel)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isParallel", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.doAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.entryAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.exitAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.stateDefinition != null)
+                {
+                    foreach (var item in poco.stateDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stateDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs
index d5084ad58..760a38175 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="StepWriter" /> is to write an instance of <see cref="IStep" />
     /// to the XMI document
     /// </summary>
-    public static class StepWriter
+    public class StepWriter : XmiDataWriter<IStep>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<StepWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StepWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public StepWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<StepWriter>.Instance : loggerFactory.CreateLogger<StepWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IStep" /> object to its XML representation
         /// </summary>
@@ -52,444 +73,1367 @@ public static class StepWriter
         /// <param name="poco">The <see cref="IStep" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IStep poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStep poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Step");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.behavior != null)
                 {
                     foreach (var item in poco.behavior)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "behavior", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "behavior", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
-                if (poco.owningType != null)
-                {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
-                }
-                if (poco.parameter != null)
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IStep" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStep" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Step");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.behavior != null)
+                {
+                    foreach (var item in poco.behavior)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "behavior", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs
index 4f99f5250..a9d2bf93e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="StructureWriter" /> is to write an instance of <see cref="IStructure" />
     /// to the XMI document
     /// </summary>
-    public static class StructureWriter
+    public class StructureWriter : XmiDataWriter<IStructure>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<StructureWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StructureWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public StructureWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<StructureWriter>.Instance : loggerFactory.CreateLogger<StructureWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IStructure" /> object to its XML representation
         /// </summary>
@@ -53,320 +74,973 @@ public static class StructureWriter
         /// <param name="poco">The <see cref="IStructure" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IStructure poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStructure poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Structure");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
-            {
-                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
-            }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
                     xmlWriter.WriteAttributeString("isConjugated", "true");
                 }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IStructure" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IStructure" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStructure poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Structure");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs
index 80c521f69..411038178 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SubclassificationWriter" /> is to write an instance of <see cref="ISubclassification" />
     /// to the XMI document
     /// </summary>
-    public static class SubclassificationWriter
+    public class SubclassificationWriter : XmiDataWriter<ISubclassification>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SubclassificationWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SubclassificationWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SubclassificationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SubclassificationWriter>.Instance : loggerFactory.CreateLogger<SubclassificationWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISubclassification" /> object to its XML representation
         /// </summary>
@@ -50,151 +71,426 @@ public static class SubclassificationWriter
         /// <param name="poco">The <see cref="ISubclassification" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISubclassification poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISubclassification poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Subclassification");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningClassifier != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningClassifier, "owningClassifier", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.Subclassifier != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Subclassifier, "subclassifier", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Subclassifier, "subclassifier", elementOriginMap, currentFileUri);
             }
+
             if (poco.Superclassifier != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Superclassifier, "superclassifier", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Superclassifier, "superclassifier", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISubclassification" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISubclassification" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISubclassification poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Subclassification");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningClassifier != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningClassifier, "owningClassifier", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningClassifier, "owningClassifier", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.Subclassifier != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.Subclassifier, "subclassifier", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.Superclassifier != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.Superclassifier, "superclassifier", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs
index 9d922b663..5d2652752 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SubjectMembershipWriter" /> is to write an instance of <see cref="ISubjectMembership" />
     /// to the XMI document
     /// </summary>
-    public static class SubjectMembershipWriter
+    public class SubjectMembershipWriter : XmiDataWriter<ISubjectMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SubjectMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SubjectMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SubjectMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SubjectMembershipWriter>.Instance : loggerFactory.CreateLogger<SubjectMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISubjectMembership" /> object to its XML representation
         /// </summary>
@@ -54,160 +75,474 @@ public static class SubjectMembershipWriter
         /// <param name="poco">The <see cref="ISubjectMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISubjectMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SubjectMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubjectParameter != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedSubjectParameter, "ownedSubjectParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISubjectMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISubjectMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SubjectMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubjectParameter != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedSubjectParameter, "ownedSubjectParameter", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedSubjectParameter, "ownedSubjectParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs
index f7747a64a..f5f05c3e7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SubsettingWriter" /> is to write an instance of <see cref="ISubsetting" />
     /// to the XMI document
     /// </summary>
-    public static class SubsettingWriter
+    public class SubsettingWriter : XmiDataWriter<ISubsetting>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SubsettingWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SubsettingWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SubsettingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SubsettingWriter>.Instance : loggerFactory.CreateLogger<SubsettingWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISubsetting" /> object to its XML representation
         /// </summary>
@@ -50,151 +71,426 @@ public static class SubsettingWriter
         /// <param name="poco">The <see cref="ISubsetting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISubsetting poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Subsetting");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeature != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.SubsettedFeature != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.SubsettedFeature, "subsettedFeature", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.SubsettedFeature, "subsettedFeature", elementOriginMap, currentFileUri);
             }
+
             if (poco.SubsettingFeature != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.SubsettingFeature, "subsettingFeature", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.SubsettingFeature, "subsettingFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISubsetting" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISubsetting" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Subsetting");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.SubsettedFeature != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.SubsettedFeature, "subsettedFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.SubsettingFeature != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.SubsettingFeature, "subsettingFeature", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs
index d3b5cdafd..499caa1ac 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -67,8 +71,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SuccessionAsUsageWriter" /> is to write an instance of <see cref="ISuccessionAsUsage" />
     /// to the XMI document
     /// </summary>
-    public static class SuccessionAsUsageWriter
+    public class SuccessionAsUsageWriter : XmiDataWriter<ISuccessionAsUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SuccessionAsUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SuccessionAsUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SuccessionAsUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SuccessionAsUsageWriter>.Instance : loggerFactory.CreateLogger<SuccessionAsUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISuccessionAsUsage" /> object to its XML representation
         /// </summary>
@@ -76,714 +97,2225 @@ public static class SuccessionAsUsageWriter
         /// <param name="poco">The <see cref="ISuccessionAsUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SuccessionAsUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.association != null)
                 {
                     foreach (var item in poco.association)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.definition != null)
                 {
                     foreach (var item in poco.definition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedRequirement != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISuccessionAsUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISuccessionAsUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SuccessionAsUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.association != null)
+                {
+                    foreach (var item in poco.association)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.definition != null)
+                {
+                    foreach (var item in poco.definition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs
index c0b2027ef..f4761be57 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -71,8 +75,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SuccessionFlowUsageWriter" /> is to write an instance of <see cref="ISuccessionFlowUsage" />
     /// to the XMI document
     /// </summary>
-    public static class SuccessionFlowUsageWriter
+    public class SuccessionFlowUsageWriter : XmiDataWriter<ISuccessionFlowUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SuccessionFlowUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SuccessionFlowUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SuccessionFlowUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SuccessionFlowUsageWriter>.Instance : loggerFactory.CreateLogger<SuccessionFlowUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISuccessionFlowUsage" /> object to its XML representation
         /// </summary>
@@ -80,756 +101,2369 @@ public static class SuccessionFlowUsageWriter
         /// <param name="poco">The <see cref="ISuccessionFlowUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SuccessionFlowUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.flowDefinition != null)
                 {
                     foreach (var item in poco.flowDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.flowEnd != null)
                 {
                     foreach (var item in poco.flowEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedReference != null)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadType != null)
                 {
                     foreach (var item in poco.payloadType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceOutputFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetInputFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISuccessionFlowUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISuccessionFlowUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SuccessionFlowUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.flowDefinition != null)
+                {
+                    foreach (var item in poco.flowDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.flowEnd != null)
+                {
+                    foreach (var item in poco.flowEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadType != null)
+                {
+                    foreach (var item in poco.payloadType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceOutputFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetInputFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs
index 5f45a0ddd..cdd1ae4c4 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -47,8 +51,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SuccessionFlowWriter" /> is to write an instance of <see cref="ISuccessionFlow" />
     /// to the XMI document
     /// </summary>
-    public static class SuccessionFlowWriter
+    public class SuccessionFlowWriter : XmiDataWriter<ISuccessionFlow>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SuccessionFlowWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SuccessionFlowWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SuccessionFlowWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SuccessionFlowWriter>.Instance : loggerFactory.CreateLogger<SuccessionFlowWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISuccessionFlow" /> object to its XML representation
         /// </summary>
@@ -56,500 +77,1549 @@ public static class SuccessionFlowWriter
         /// <param name="poco">The <see cref="ISuccessionFlow" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SuccessionFlow");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.flowEnd != null)
                 {
                     foreach (var item in poco.flowEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.interaction != null)
                 {
                     foreach (var item in poco.interaction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interaction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "interaction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedTyping != null)
-                {
-                    foreach (var item in poco.ownedTyping)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.payloadType != null)
                 {
                     foreach (var item in poco.payloadType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceOutputFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetInputFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISuccessionFlow" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISuccessionFlow" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SuccessionFlow");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.flowEnd != null)
+                {
+                    foreach (var item in poco.flowEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.interaction != null)
+                {
+                    foreach (var item in poco.interaction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "interaction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.payloadType != null)
+                {
+                    foreach (var item in poco.payloadType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceOutputFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetInputFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs
index f27b9b098..63aee085b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -44,8 +48,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="SuccessionWriter" /> is to write an instance of <see cref="ISuccession" />
     /// to the XMI document
     /// </summary>
-    public static class SuccessionWriter
+    public class SuccessionWriter : XmiDataWriter<ISuccession>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<SuccessionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SuccessionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public SuccessionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<SuccessionWriter>.Instance : loggerFactory.CreateLogger<SuccessionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ISuccession" /> object to its XML representation
         /// </summary>
@@ -53,474 +74,1457 @@ public static class SuccessionWriter
         /// <param name="poco">The <see cref="ISuccession" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ISuccession poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISuccession poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Succession");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
-                {
-                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
-                }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelatedElement != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelatedElement)
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
             }
-            if (poco.OwnedRelationship != null)
+
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelatedElement != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.association != null)
                 {
                     foreach (var item in poco.association)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.defaultFeaturingType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedTyping != null)
-                {
-                    foreach (var item in poco.ownedTyping)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.sourceFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ISuccession" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ISuccession" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Succession");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.association != null)
+                {
+                    foreach (var item in poco.association)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.connectorEnd != null)
+                {
+                    foreach (var item in poco.connectorEnd)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.defaultFeaturingType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedFeature != null)
+                {
+                    foreach (var item in poco.relatedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.sourceFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.targetFeature != null)
+                {
+                    foreach (var item in poco.targetFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs
index eb04b58cc..a9c16acd4 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="TerminateActionUsageWriter" /> is to write an instance of <see cref="ITerminateActionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class TerminateActionUsageWriter
+    public class TerminateActionUsageWriter : XmiDataWriter<ITerminateActionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<TerminateActionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TerminateActionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public TerminateActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<TerminateActionUsageWriter>.Instance : loggerFactory.CreateLogger<TerminateActionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ITerminateActionUsage" /> object to its XML representation
         /// </summary>
@@ -78,690 +99,2159 @@ public static class TerminateActionUsageWriter
         /// <param name="poco">The <see cref="ITerminateActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TerminateActionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUsage != null)
-                {
-                    foreach (var item in poco.nestedUsage)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.terminatedOccurrenceArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.terminatedOccurrenceArgument, "terminatedOccurrenceArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.terminatedOccurrenceArgument, "terminatedOccurrenceArgument", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ITerminateActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITerminateActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TerminateActionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.terminatedOccurrenceArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.terminatedOccurrenceArgument, "terminatedOccurrenceArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs
index 517b08398..d4a4eda91 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
@@ -39,8 +43,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="TextualRepresentationWriter" /> is to write an instance of <see cref="ITextualRepresentation" />
     /// to the XMI document
     /// </summary>
-    public static class TextualRepresentationWriter
+    public class TextualRepresentationWriter : XmiDataWriter<ITextualRepresentation>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<TextualRepresentationWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TextualRepresentationWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public TextualRepresentationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<TextualRepresentationWriter>.Instance : loggerFactory.CreateLogger<TextualRepresentationWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ITextualRepresentation" /> object to its XML representation
         /// </summary>
@@ -48,147 +69,428 @@ public static class TextualRepresentationWriter
         /// <param name="poco">The <see cref="ITextualRepresentation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ITextualRepresentation poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TextualRepresentation");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.Body))
             {
                 xmlWriter.WriteAttributeString("body", poco.Body);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            if (!string.IsNullOrWhiteSpace(poco.Language))
-            {
-                xmlWriter.WriteAttributeString("language", poco.Language);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Language))
+            {
+                xmlWriter.WriteAttributeString("language", poco.Language);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.annotation != null)
+                {
+                    foreach (var item in poco.annotation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotatingRelationship != null)
+                {
+                    foreach (var item in poco.ownedAnnotatingRelationship)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningAnnotatingRelationship != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.representedElement != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.representedElement, "representedElement", elementOriginMap, currentFileUri);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ITextualRepresentation" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITextualRepresentation" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITextualRepresentation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TextualRepresentation");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Body))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "body", null, poco.Body);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.Language))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "language", null, poco.Language);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningAnnotatingRelationship != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.representedElement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.representedElement, "representedElement", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.representedElement, "representedElement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs
index 962a2dd55..861ec7767 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.States;
@@ -45,8 +49,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="TransitionFeatureMembershipWriter" /> is to write an instance of <see cref="ITransitionFeatureMembership" />
     /// to the XMI document
     /// </summary>
-    public static class TransitionFeatureMembershipWriter
+    public class TransitionFeatureMembershipWriter : XmiDataWriter<ITransitionFeatureMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<TransitionFeatureMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TransitionFeatureMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public TransitionFeatureMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<TransitionFeatureMembershipWriter>.Instance : loggerFactory.CreateLogger<TransitionFeatureMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ITransitionFeatureMembership" /> object to its XML representation
         /// </summary>
@@ -54,161 +75,478 @@ public static class TransitionFeatureMembershipWriter
         /// <param name="poco">The <see cref="ITransitionFeatureMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TransitionFeatureMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.transitionFeature != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.transitionFeature, "transitionFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ITransitionFeatureMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITransitionFeatureMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TransitionFeatureMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.transitionFeature != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.transitionFeature, "transitionFeature", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.transitionFeature, "transitionFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs
index c53a659e6..08e196320 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -70,8 +74,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="TransitionUsageWriter" /> is to write an instance of <see cref="ITransitionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class TransitionUsageWriter
+    public class TransitionUsageWriter : XmiDataWriter<ITransitionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<TransitionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TransitionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public TransitionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<TransitionUsageWriter>.Instance : loggerFactory.CreateLogger<TransitionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ITransitionUsage" /> object to its XML representation
         /// </summary>
@@ -79,719 +100,2257 @@ public static class TransitionUsageWriter
         /// <param name="poco">The <see cref="ITransitionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ITransitionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TransitionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.effectAction != null)
                 {
                     foreach (var item in poco.effectAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "effectAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "effectAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.guardExpression != null)
                 {
                     foreach (var item in poco.guardExpression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "guardExpression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "guardExpression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedState != null)
-                {
-                    foreach (var item in poco.nestedState)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.source != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.source, "source", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.source, "source", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.succession != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.succession, "succession", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.succession, "succession", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.target != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.target, "target", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.target, "target", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.triggerAction != null)
                 {
                     foreach (var item in poco.triggerAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "triggerAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "triggerAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ITransitionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITransitionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TransitionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.effectAction != null)
+                {
+                    foreach (var item in poco.effectAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "effectAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.guardExpression != null)
+                {
+                    foreach (var item in poco.guardExpression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "guardExpression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.source != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.source, "source", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.succession != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.succession, "succession", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.target != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.target, "target", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.triggerAction != null)
+                {
+                    foreach (var item in poco.triggerAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "triggerAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs
index 58ceda4b9..68532eace 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Actions;
@@ -47,8 +51,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="TriggerInvocationExpressionWriter" /> is to write an instance of <see cref="ITriggerInvocationExpression" />
     /// to the XMI document
     /// </summary>
-    public static class TriggerInvocationExpressionWriter
+    public class TriggerInvocationExpressionWriter : XmiDataWriter<ITriggerInvocationExpression>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<TriggerInvocationExpressionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TriggerInvocationExpressionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public TriggerInvocationExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<TriggerInvocationExpressionWriter>.Instance : loggerFactory.CreateLogger<TriggerInvocationExpressionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ITriggerInvocationExpression" /> object to its XML representation
         /// </summary>
@@ -56,461 +77,1435 @@ public static class TriggerInvocationExpressionWriter
         /// <param name="poco">The <see cref="ITriggerInvocationExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TriggerInvocationExpression");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariable)
             {
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
+
             xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.function != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.instantiatedType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedUnioning != null)
-                {
-                    foreach (var item in poco.ownedUnioning)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ITriggerInvocationExpression" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITriggerInvocationExpression" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TriggerInvocationExpression");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariable)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.argument != null)
+                {
+                    foreach (var item in poco.argument)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.function != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.instantiatedType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.type != null)
+                {
+                    foreach (var item in poco.type)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs
index d707ac01f..0fc5fdd80 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="TypeFeaturingWriter" /> is to write an instance of <see cref="ITypeFeaturing" />
     /// to the XMI document
     /// </summary>
-    public static class TypeFeaturingWriter
+    public class TypeFeaturingWriter : XmiDataWriter<ITypeFeaturing>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<TypeFeaturingWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TypeFeaturingWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public TypeFeaturingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<TypeFeaturingWriter>.Instance : loggerFactory.CreateLogger<TypeFeaturingWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="ITypeFeaturing" /> object to its XML representation
         /// </summary>
@@ -50,151 +71,426 @@ public static class TypeFeaturingWriter
         /// <param name="poco">The <see cref="ITypeFeaturing" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TypeFeaturing");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.FeatureOfType != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeatureOfType, "featureOfType", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeatureOfType, "featureOfType", elementOriginMap, currentFileUri);
             }
+
             if (poco.FeaturingType != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeaturingType, "featuringType", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeaturingType, "featuringType", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureOfType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureOfType, "owningFeatureOfType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="ITypeFeaturing" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="ITypeFeaturing" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITypeFeaturing poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TypeFeaturing");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.FeatureOfType != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.FeatureOfType, "featureOfType", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.FeaturingType != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.FeaturingType, "featuringType", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureOfType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureOfType, "owningFeatureOfType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureOfType, "owningFeatureOfType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs
index e884fcd13..ec37464d6 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="TypeWriter" /> is to write an instance of <see cref="IType" />
     /// to the XMI document
     /// </summary>
-    public static class TypeWriter
+    public class TypeWriter : XmiDataWriter<IType>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<TypeWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TypeWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public TypeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<TypeWriter>.Instance : loggerFactory.CreateLogger<TypeWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IType" /> object to its XML representation
         /// </summary>
@@ -50,313 +71,951 @@ public static class TypeWriter
         /// <param name="poco">The <see cref="IType" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IType poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IType poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Type");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
-            {
-                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
-            }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
                     xmlWriter.WriteAttributeString("isConjugated", "true");
                 }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IType" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IType" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IType poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Type");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs
index 1fb4b40fe..98a4b8f6b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -40,8 +44,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="UnioningWriter" /> is to write an instance of <see cref="IUnioning" />
     /// to the XMI document
     /// </summary>
-    public static class UnioningWriter
+    public class UnioningWriter : XmiDataWriter<IUnioning>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<UnioningWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnioningWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public UnioningWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<UnioningWriter>.Instance : loggerFactory.CreateLogger<UnioningWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IUnioning" /> object to its XML representation
         /// </summary>
@@ -49,147 +70,416 @@ public static class UnioningWriter
         /// <param name="poco">The <see cref="IUnioning" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IUnioning poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Unioning");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.typeUnioned != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeUnioned, "typeUnioned", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.UnioningType != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.UnioningType, "unioningType", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.UnioningType, "unioningType", elementOriginMap, currentFileUri);
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IUnioning" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IUnioning" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IUnioning poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Unioning");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.typeUnioned != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeUnioned, "typeUnioned", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.typeUnioned, "typeUnioned", elementOriginMap, currentFileUri);
                 }
             }
 
-            xmlWriter.WriteEndElement();
+            if (poco.UnioningType != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.UnioningType, "unioningType", elementOriginMap, currentFileUri);
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs
index 826bd7b66..0b92c5ad9 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="UsageWriter" /> is to write an instance of <see cref="IUsage" />
     /// to the XMI document
     /// </summary>
-    public static class UsageWriter
+    public class UsageWriter : XmiDataWriter<IUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<UsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public UsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<UsageWriter>.Instance : loggerFactory.CreateLogger<UsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IUsage" /> object to its XML representation
         /// </summary>
@@ -74,670 +95,2091 @@ public static class UsageWriter
         /// <param name="poco">The <see cref="IUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Usage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.definition != null)
                 {
                     foreach (var item in poco.definition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedUseCase != null)
-                {
-                    foreach (var item in poco.nestedUseCase)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Usage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.definition != null)
+                {
+                    foreach (var item in poco.definition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs
index f4a016b80..9a3326b1c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="UseCaseDefinitionWriter" /> is to write an instance of <see cref="IUseCaseDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class UseCaseDefinitionWriter
+    public class UseCaseDefinitionWriter : XmiDataWriter<IUseCaseDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<UseCaseDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UseCaseDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public UseCaseDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<UseCaseDefinitionWriter>.Instance : loggerFactory.CreateLogger<UseCaseDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IUseCaseDefinition" /> object to its XML representation
         /// </summary>
@@ -75,603 +96,1871 @@ public static class UseCaseDefinitionWriter
         /// <param name="poco">The <see cref="IUseCaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:UseCaseDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
-            if (poco.IsVariation)
-            {
-                xmlWriter.WriteAttributeString("isVariation", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.calculation != null)
                 {
                     foreach (var item in poco.calculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.includedUseCase != null)
                 {
                     foreach (var item in poco.includedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.objectiveRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedOccurrence != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IUseCaseDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IUseCaseDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:UseCaseDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.calculation != null)
+                {
+                    foreach (var item in poco.calculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.includedUseCase != null)
+                {
+                    foreach (var item in poco.includedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.objectiveRequirement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs
index 887af6ba4..dcc5779be 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="UseCaseUsageWriter" /> is to write an instance of <see cref="IUseCaseUsage" />
     /// to the XMI document
     /// </summary>
-    public static class UseCaseUsageWriter
+    public class UseCaseUsageWriter : XmiDataWriter<IUseCaseUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<UseCaseUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UseCaseUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public UseCaseUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<UseCaseUsageWriter>.Instance : loggerFactory.CreateLogger<UseCaseUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IUseCaseUsage" /> object to its XML representation
         /// </summary>
@@ -78,720 +99,2267 @@ public static class UseCaseUsageWriter
         /// <param name="poco">The <see cref="IUseCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:UseCaseUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.includedUseCase != null)
                 {
                     foreach (var item in poco.includedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedReference != null)
-                {
-                    foreach (var item in poco.nestedReference)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.objectiveRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.useCaseDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IUseCaseUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IUseCaseUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:UseCaseUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.includedUseCase != null)
+                {
+                    foreach (var item in poco.includedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.objectiveRequirement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.useCaseDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs
index 988fa9bbb..72e29d511 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -41,8 +45,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="VariantMembershipWriter" /> is to write an instance of <see cref="IVariantMembership" />
     /// to the XMI document
     /// </summary>
-    public static class VariantMembershipWriter
+    public class VariantMembershipWriter : XmiDataWriter<IVariantMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<VariantMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VariantMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public VariantMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<VariantMembershipWriter>.Instance : loggerFactory.CreateLogger<VariantMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IVariantMembership" /> object to its XML representation
         /// </summary>
@@ -50,160 +71,474 @@ public static class VariantMembershipWriter
         /// <param name="poco">The <see cref="IVariantMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IVariantMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:VariantMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membershipOwningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVariantUsage != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedVariantUsage, "ownedVariantUsage", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IVariantMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IVariantMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:VariantMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membershipOwningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVariantUsage != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedVariantUsage, "ownedVariantUsage", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedVariantUsage, "ownedVariantUsage", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs
index 3bc489db6..72763f83d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="VerificationCaseDefinitionWriter" /> is to write an instance of <see cref="IVerificationCaseDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class VerificationCaseDefinitionWriter
+    public class VerificationCaseDefinitionWriter : XmiDataWriter<IVerificationCaseDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<VerificationCaseDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VerificationCaseDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public VerificationCaseDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<VerificationCaseDefinitionWriter>.Instance : loggerFactory.CreateLogger<VerificationCaseDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IVerificationCaseDefinition" /> object to its XML representation
         /// </summary>
@@ -75,603 +96,1871 @@ public static class VerificationCaseDefinitionWriter
         /// <param name="poco">The <see cref="IVerificationCaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:VerificationCaseDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
-            if (poco.IsVariation)
-            {
-                xmlWriter.WriteAttributeString("isVariation", "true");
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.calculation != null)
                 {
                     foreach (var item in poco.calculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.objectiveRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedPart != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.verifiedRequirement != null)
                 {
                     foreach (var item in poco.verifiedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "verifiedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "verifiedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IVerificationCaseDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IVerificationCaseDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:VerificationCaseDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.action != null)
+                {
+                    foreach (var item in poco.action)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.calculation != null)
+                {
+                    foreach (var item in poco.calculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.objectiveRequirement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.verifiedRequirement != null)
+                {
+                    foreach (var item in poco.verifiedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "verifiedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs
index 263c2d472..4dac4dec2 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="VerificationCaseUsageWriter" /> is to write an instance of <see cref="IVerificationCaseUsage" />
     /// to the XMI document
     /// </summary>
-    public static class VerificationCaseUsageWriter
+    public class VerificationCaseUsageWriter : XmiDataWriter<IVerificationCaseUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<VerificationCaseUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VerificationCaseUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public VerificationCaseUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<VerificationCaseUsageWriter>.Instance : loggerFactory.CreateLogger<VerificationCaseUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IVerificationCaseUsage" /> object to its XML representation
         /// </summary>
@@ -78,724 +99,2283 @@ public static class VerificationCaseUsageWriter
         /// <param name="poco">The <see cref="IVerificationCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:VerificationCaseUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.caseDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedReference != null)
-                {
-                    foreach (var item in poco.nestedReference)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.objectiveRequirement != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.verificationCaseDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.verificationCaseDefinition, "verificationCaseDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.verificationCaseDefinition, "verificationCaseDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.verifiedRequirement != null)
                 {
                     foreach (var item in poco.verifiedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "verifiedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "verifiedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IVerificationCaseUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IVerificationCaseUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:VerificationCaseUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.caseDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.objectiveRequirement != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.verificationCaseDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.verificationCaseDefinition, "verificationCaseDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.verifiedRequirement != null)
+                {
+                    foreach (var item in poco.verifiedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "verifiedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs
index ccbd533a9..7914c8630 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -65,8 +69,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ViewDefinitionWriter" /> is to write an instance of <see cref="IViewDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class ViewDefinitionWriter
+    public class ViewDefinitionWriter : XmiDataWriter<IViewDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ViewDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ViewDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ViewDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ViewDefinitionWriter>.Instance : loggerFactory.CreateLogger<ViewDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IViewDefinition" /> object to its XML representation
         /// </summary>
@@ -74,570 +95,1757 @@ public static class ViewDefinitionWriter
         /// <param name="poco">The <see cref="IViewDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IViewDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedSpecialization != null)
-                {
-                    foreach (var item in poco.ownedSpecialization)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.satisfiedViewpoint != null)
                 {
                     foreach (var item in poco.satisfiedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.view != null)
                 {
                     foreach (var item in poco.view)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "view", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "view", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.viewCondition != null)
                 {
                     foreach (var item in poco.viewCondition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewCondition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewCondition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.viewRendering != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IViewDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IViewDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ViewDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.satisfiedViewpoint != null)
+                {
+                    foreach (var item in poco.satisfiedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.view != null)
+                {
+                    foreach (var item in poco.view)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "view", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.viewCondition != null)
+                {
+                    foreach (var item in poco.viewCondition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "viewCondition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.viewRendering != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs
index 461b45e79..049bd40f8 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -43,8 +47,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ViewRenderingMembershipWriter" /> is to write an instance of <see cref="IViewRenderingMembership" />
     /// to the XMI document
     /// </summary>
-    public static class ViewRenderingMembershipWriter
+    public class ViewRenderingMembershipWriter : XmiDataWriter<IViewRenderingMembership>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ViewRenderingMembershipWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ViewRenderingMembershipWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ViewRenderingMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ViewRenderingMembershipWriter>.Instance : loggerFactory.CreateLogger<ViewRenderingMembershipWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IViewRenderingMembership" /> object to its XML representation
         /// </summary>
@@ -52,164 +73,490 @@ public static class ViewRenderingMembershipWriter
         /// <param name="poco">The <see cref="IViewRenderingMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewRenderingMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberElementId", poco.ownedMemberElementId);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberName", poco.ownedMemberName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
                     xmlWriter.WriteAttributeString("ownedMemberShortName", poco.ownedMemberShortName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
 
-            // Reference/containment properties as child elements
+            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
             if (poco.OwnedRelatedElement != null)
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
             if (poco.OwnedRelationship != null)
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedRendering, "ownedRendering", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
             if (poco.OwningRelatedElement != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
             }
+
             if (poco.OwningRelationship != null)
             {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.referencedRendering != null)
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedRendering, "referencedRendering", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.relatedElement != null)
+                {
+                    foreach (var item in poco.relatedElement)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                    }
+                }
             }
 
-            // Derived reference/containment properties as child elements
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            xmlWriter.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IViewRenderingMembership" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IViewRenderingMembership" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ViewRenderingMembership");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsImplied)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElementId", null, poco.ownedMemberElementId);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberName", null, poco.ownedMemberName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberShortName", null, poco.ownedMemberShortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelatedElement != null)
+            {
+                foreach (var item in poco.OwnedRelatedElement)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedRendering, "ownedRendering", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedRendering, "ownedRendering", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelatedElement != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.referencedRendering != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedRendering, "referencedRendering", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referencedRendering, "referencedRendering", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            xmlWriter.WriteEndElement();
+
+            await xmlWriter.WriteEndElementAsync();
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs
index c345f2ddf..1315a2103 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ViewUsageWriter" /> is to write an instance of <see cref="IViewUsage" />
     /// to the XMI document
     /// </summary>
-    public static class ViewUsageWriter
+    public class ViewUsageWriter : XmiDataWriter<IViewUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ViewUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ViewUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ViewUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ViewUsageWriter>.Instance : loggerFactory.CreateLogger<ViewUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IViewUsage" /> object to its XML representation
         /// </summary>
@@ -78,715 +99,2241 @@ public static class ViewUsageWriter
         /// <param name="poco">The <see cref="IViewUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IViewUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.exposedElement != null)
                 {
                     foreach (var item in poco.exposedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "exposedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "exposedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedState != null)
-                {
-                    foreach (var item in poco.nestedState)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.satisfiedViewpoint != null)
                 {
                     foreach (var item in poco.satisfiedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.viewCondition != null)
                 {
                     foreach (var item in poco.viewCondition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewCondition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewCondition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.viewDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewDefinition, "viewDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewDefinition, "viewDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.viewRendering != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IViewUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IViewUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ViewUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedFeature != null)
+                {
+                    foreach (var item in poco.directedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.exposedElement != null)
+                {
+                    foreach (var item in poco.exposedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "exposedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.itemDefinition != null)
+                {
+                    foreach (var item in poco.itemDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.satisfiedViewpoint != null)
+                {
+                    foreach (var item in poco.satisfiedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.viewCondition != null)
+                {
+                    foreach (var item in poco.viewCondition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "viewCondition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.viewDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.viewDefinition, "viewDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.viewRendering != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs
index 314cfb490..3f761ccf3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -66,8 +70,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ViewpointDefinitionWriter" /> is to write an instance of <see cref="IViewpointDefinition" />
     /// to the XMI document
     /// </summary>
-    public static class ViewpointDefinitionWriter
+    public class ViewpointDefinitionWriter : XmiDataWriter<IViewpointDefinition>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ViewpointDefinitionWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ViewpointDefinitionWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ViewpointDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ViewpointDefinitionWriter>.Instance : loggerFactory.CreateLogger<ViewpointDefinitionWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IViewpointDefinition" /> object to its XML representation
         /// </summary>
@@ -75,617 +96,1915 @@ public static class ViewpointDefinitionWriter
         /// <param name="poco">The <see cref="IViewpointDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IViewpointDefinition poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewpointDefinition");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
-            if (poco.IsSufficient)
-            {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
-            }
-            if (poco.IsVariation)
-            {
-                xmlWriter.WriteAttributeString("isVariation", "true");
-            }
-            if (!string.IsNullOrWhiteSpace(poco.ReqId))
-            {
-                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
                 if (poco.isLibraryElement)
                 {
                     xmlWriter.WriteAttributeString("isLibraryElement", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.isModelLevelEvaluable)
                 {
                     xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
                 }
+            }
+
+            if (poco.IsSufficient)
+            {
+                xmlWriter.WriteAttributeString("isSufficient", "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                xmlWriter.WriteAttributeString("isVariation", "true");
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
-                if (poco.text != null && poco.text.Count > 0)
-                {
-                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (poco.text != null && poco.text.Count > 0)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.ownedMetadata != null)
-                {
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.viewpointStakeholder != null)
                 {
                     foreach (var item in poco.viewpointStakeholder)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewpointStakeholder", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewpointStakeholder", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IViewpointDefinition" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IViewpointDefinition" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ViewpointDefinition");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "text", null, string.Join(" ", poco.text));
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.expression != null)
+                {
+                    foreach (var item in poco.expression)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAction != null)
+                {
+                    foreach (var item in poco.ownedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAllocation != null)
+                {
+                    foreach (var item in poco.ownedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnalysisCase != null)
+                {
+                    foreach (var item in poco.ownedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAttribute != null)
+                {
+                    foreach (var item in poco.ownedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCalculation != null)
+                {
+                    foreach (var item in poco.ownedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCase != null)
+                {
+                    foreach (var item in poco.ownedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConcern != null)
+                {
+                    foreach (var item in poco.ownedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConnection != null)
+                {
+                    foreach (var item in poco.ownedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConstraint != null)
+                {
+                    foreach (var item in poco.ownedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEnumeration != null)
+                {
+                    foreach (var item in poco.ownedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFlow != null)
+                {
+                    foreach (var item in poco.ownedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedInterface != null)
+                {
+                    foreach (var item in poco.ownedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedItem != null)
+                {
+                    foreach (var item in poco.ownedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMetadata != null)
+                {
+                    foreach (var item in poco.ownedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedOccurrence != null)
+                {
+                    foreach (var item in poco.ownedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPart != null)
+                {
+                    foreach (var item in poco.ownedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedPort != null)
+                {
+                    foreach (var item in poco.ownedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReference != null)
+                {
+                    foreach (var item in poco.ownedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRendering != null)
+                {
+                    foreach (var item in poco.ownedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRequirement != null)
+                {
+                    foreach (var item in poco.ownedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedState != null)
+                {
+                    foreach (var item in poco.ownedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubclassification != null)
+                {
+                    foreach (var item in poco.ownedSubclassification)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTransition != null)
+                {
+                    foreach (var item in poco.ownedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUsage != null)
+                {
+                    foreach (var item in poco.ownedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUseCase != null)
+                {
+                    foreach (var item in poco.ownedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedVerificationCase != null)
+                {
+                    foreach (var item in poco.ownedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedView != null)
+                {
+                    foreach (var item in poco.ownedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedViewpoint != null)
+                {
+                    foreach (var item in poco.ownedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.step != null)
+                {
+                    foreach (var item in poco.step)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.viewpointStakeholder != null)
+                {
+                    foreach (var item in poco.viewpointStakeholder)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "viewpointStakeholder", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs
index 97971694a..57a8d878b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="ViewpointUsageWriter" /> is to write an instance of <see cref="IViewpointUsage" />
     /// to the XMI document
     /// </summary>
-    public static class ViewpointUsageWriter
+    public class ViewpointUsageWriter : XmiDataWriter<IViewpointUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<ViewpointUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ViewpointUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public ViewpointUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<ViewpointUsageWriter>.Instance : loggerFactory.CreateLogger<ViewpointUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IViewpointUsage" /> object to its XML representation
         /// </summary>
@@ -78,741 +99,2333 @@ public static class ViewpointUsageWriter
         /// <param name="poco">The <see cref="IViewpointUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IViewpointUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewpointUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
-            if (!string.IsNullOrWhiteSpace(poco.ReqId))
-            {
-                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
-            }
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isModelLevelEvaluable)
-                {
-                    xmlWriter.WriteAttributeString("isModelLevelEvaluable", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                xmlWriter.WriteAttributeString("reqId", poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
                     xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
-                if (poco.text != null && poco.text.Count > 0)
-                {
-                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (poco.text != null && poco.text.Count > 0)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("text", string.Join(" ", poco.text));
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedOccurrence != null)
-                {
-                    foreach (var item in poco.nestedOccurrence)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.result != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.subjectParameter != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.viewpointDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewpointDefinition, "viewpointDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewpointDefinition, "viewpointDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.viewpointStakeholder != null)
                 {
                     foreach (var item in poco.viewpointStakeholder)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewpointStakeholder", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "viewpointStakeholder", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IViewpointUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IViewpointUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ViewpointUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isModelLevelEvaluable)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isModelLevelEvaluable", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.ReqId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.text != null && poco.text.Count > 0)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "text", null, string.Join(" ", poco.text));
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actorParameter != null)
+                {
+                    foreach (var item in poco.actorParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.assumedConstraint != null)
+                {
+                    foreach (var item in poco.assumedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.framedConcern != null)
+                {
+                    foreach (var item in poco.framedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.requiredConstraint != null)
+                {
+                    foreach (var item in poco.requiredConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.result != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.stakeholderParameter != null)
+                {
+                    foreach (var item in poco.stakeholderParameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.subjectParameter != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.viewpointDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.viewpointDefinition, "viewpointDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.viewpointStakeholder != null)
+                {
+                    foreach (var item in poco.viewpointStakeholder)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "viewpointStakeholder", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs
index d01cf68a6..eefe97659 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs
@@ -27,8 +27,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
@@ -69,8 +73,25 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// The purpose of the <see cref="WhileLoopActionUsageWriter" /> is to write an instance of <see cref="IWhileLoopActionUsage" />
     /// to the XMI document
     /// </summary>
-    public static class WhileLoopActionUsageWriter
+    public class WhileLoopActionUsageWriter : XmiDataWriter<IWhileLoopActionUsage>
     {
+        /// <summary>
+        /// The instantiated logger from the injected <see cref="ILoggerFactory" />
+        /// </summary>
+        private readonly ILogger<WhileLoopActionUsageWriter> logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WhileLoopActionUsageWriter" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        public WhileLoopActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory) : base(xmiDataWriterFacade, loggerFactory)
+        {
+            this.logger = loggerFactory == null ? NullLogger<WhileLoopActionUsageWriter>.Instance : loggerFactory.CreateLogger<WhileLoopActionUsageWriter>();
+        }
+
         /// <summary>
         /// Writes the <see cref="IWhileLoopActionUsage" /> object to its XML representation
         /// </summary>
@@ -78,698 +99,2191 @@ public static class WhileLoopActionUsageWriter
         /// <param name="poco">The <see cref="IWhileLoopActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="xmiWriterFacade">The <see cref="IXmiDataWriterFacade" /> for writing child elements</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public static void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, string elementName, bool includeDerivedProperties, IXmiDataWriterFacade xmiWriterFacade, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:WhileLoopActionUsage");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
-            // Scalar properties as XML attributes
+            // Scalar properties as XML attributes (sorted alphabetically)
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
             {
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
+
             xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
+
             if (poco.IsComposite)
             {
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    xmlWriter.WriteAttributeString("isConjugated", "true");
+                }
+            }
+
             if (poco.IsConstant)
             {
                 xmlWriter.WriteAttributeString("isConstant", "true");
             }
+
             if (poco.IsDerived)
             {
                 xmlWriter.WriteAttributeString("isDerived", "true");
             }
+
             if (poco.IsEnd)
             {
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
-            if (poco.IsImpliedIncluded)
+
+            if (includesImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
+
             if (poco.IsIndividual)
             {
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
+                }
+            }
+
             if (poco.IsOrdered)
             {
                 xmlWriter.WriteAttributeString("isOrdered", "true");
             }
+
             if (poco.IsPortion)
             {
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    xmlWriter.WriteAttributeString("isReference", "true");
+                }
+            }
+
             if (poco.IsSufficient)
             {
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
+
             if (poco.IsUnique)
             {
                 xmlWriter.WriteAttributeString("isUnique", "true");
             }
+
             if (poco.IsVariation)
             {
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
 
-            // Derived scalar properties
             if (includeDerivedProperties)
             {
-                if (poco.isConjugated)
-                {
-                    xmlWriter.WriteAttributeString("isConjugated", "true");
-                }
-                if (poco.isLibraryElement)
-                {
-                    xmlWriter.WriteAttributeString("isLibraryElement", "true");
-                }
-                if (poco.isReference)
-                {
-                    xmlWriter.WriteAttributeString("isReference", "true");
-                }
                 if (poco.mayTimeVary)
                 {
                     xmlWriter.WriteAttributeString("mayTimeVary", "true");
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
                     xmlWriter.WriteAttributeString("name", poco.name);
                 }
+            }
+
+            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
                     xmlWriter.WriteAttributeString("qualifiedName", poco.qualifiedName);
                 }
-                if (!string.IsNullOrWhiteSpace(poco.shortName))
-                {
-                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
-                }
             }
 
-            // Reference/containment properties as child elements
-            if (poco.OwnedRelationship != null)
+            if (includeDerivedProperties)
             {
-                foreach (var item in poco.OwnedRelationship)
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    xmlWriter.WriteAttributeString("shortName", poco.shortName);
                 }
             }
-            if (poco.OwningRelationship != null)
-            {
-                xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
 
-            // Derived reference/containment properties as child elements
+
+            // Reference/containment properties as child elements (sorted alphabetically)
             if (includeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.bodyAction != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.crossFeature != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.endOwningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featureTarget != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.individualDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.multiplicity != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
-                if (poco.nestedTransition != null)
-                {
-                    foreach (var item in poco.nestedTransition)
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedConjugator != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owner != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningDefinition != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningFeatureMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningMembership != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningNamespace != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningType != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.owningUsage != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.untilArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.untilArgument, "untilArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.untilArgument, "untilArgument", elementOriginMap, currentFileUri);
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        xmiWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
                     }
                 }
+            }
+
+            if (includeDerivedProperties)
+            {
                 if (poco.whileArgument != null)
                 {
-                    xmiWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.whileArgument, "whileArgument", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.whileArgument, "whileArgument", elementOriginMap, currentFileUri);
                 }
             }
 
+
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="IWhileLoopActionUsage" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="poco">The <see cref="IWhileLoopActionUsage" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>        
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:WhileLoopActionUsage");
+            await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
+
+            // Scalar properties as XML attributes (sorted alphabetically)
+            if (poco.AliasIds != null && poco.AliasIds.Count > 0)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
+            }
+
+            if (!string.IsNullOrWhiteSpace(poco.DeclaredShortName))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+
+            if (!string.IsNullOrWhiteSpace(poco.ElementId))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
+            }
+
+            if (poco.IsAbstract)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
+            }
+
+            if (poco.IsComposite)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isConjugated)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isConjugated", null, "true");
+                }
+            }
+
+            if (poco.IsConstant)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isConstant", null, "true");
+            }
+
+            if (poco.IsDerived)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isDerived", null, "true");
+            }
+
+            if (poco.IsEnd)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
+            }
+
+            if (includesImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+
+            if (poco.IsIndividual)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isLibraryElement)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isLibraryElement", null, "true");
+                }
+            }
+
+            if (poco.IsOrdered)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isOrdered", null, "true");
+            }
+
+            if (poco.IsPortion)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.isReference)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                }
+            }
+
+            if (poco.IsSufficient)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+            }
+
+            if (poco.IsUnique)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+            }
+
+            if (poco.IsVariation)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.mayTimeVary)
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "mayTimeVary", null, "true");
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.name))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "name", null, poco.name);
+                }
+            }
+
+            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "qualifiedName", null, poco.qualifiedName);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(poco.shortName))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "shortName", null, poco.shortName);
+                }
+            }
+
+
+            // Reference/containment properties as child elements (sorted alphabetically)
+            if (includeDerivedProperties)
+            {
+                if (poco.actionDefinition != null)
+                {
+                    foreach (var item in poco.actionDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.bodyAction != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.chainingFeature != null)
+                {
+                    foreach (var item in poco.chainingFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.crossFeature != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.differencingType != null)
+                {
+                    foreach (var item in poco.differencingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.directedUsage != null)
+                {
+                    foreach (var item in poco.directedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.documentation != null)
+                {
+                    foreach (var item in poco.documentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endFeature != null)
+                {
+                    foreach (var item in poco.endFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.endOwningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.feature != null)
+                {
+                    foreach (var item in poco.feature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureMembership != null)
+                {
+                    foreach (var item in poco.featureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featureTarget != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.featuringType != null)
+                {
+                    foreach (var item in poco.featuringType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.importedMembership != null)
+                {
+                    foreach (var item in poco.importedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.individualDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedFeature != null)
+                {
+                    foreach (var item in poco.inheritedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.inheritedMembership != null)
+                {
+                    foreach (var item in poco.inheritedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.input != null)
+                {
+                    foreach (var item in poco.input)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.intersectingType != null)
+                {
+                    foreach (var item in poco.intersectingType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.member != null)
+                {
+                    foreach (var item in poco.member)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.membership != null)
+                {
+                    foreach (var item in poco.membership)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.multiplicity != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAction != null)
+                {
+                    foreach (var item in poco.nestedAction)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAllocation != null)
+                {
+                    foreach (var item in poco.nestedAllocation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAnalysisCase != null)
+                {
+                    foreach (var item in poco.nestedAnalysisCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedAttribute != null)
+                {
+                    foreach (var item in poco.nestedAttribute)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCalculation != null)
+                {
+                    foreach (var item in poco.nestedCalculation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedCase != null)
+                {
+                    foreach (var item in poco.nestedCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConcern != null)
+                {
+                    foreach (var item in poco.nestedConcern)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConnection != null)
+                {
+                    foreach (var item in poco.nestedConnection)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedConstraint != null)
+                {
+                    foreach (var item in poco.nestedConstraint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedEnumeration != null)
+                {
+                    foreach (var item in poco.nestedEnumeration)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedFlow != null)
+                {
+                    foreach (var item in poco.nestedFlow)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedInterface != null)
+                {
+                    foreach (var item in poco.nestedInterface)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedItem != null)
+                {
+                    foreach (var item in poco.nestedItem)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedMetadata != null)
+                {
+                    foreach (var item in poco.nestedMetadata)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedOccurrence != null)
+                {
+                    foreach (var item in poco.nestedOccurrence)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPart != null)
+                {
+                    foreach (var item in poco.nestedPart)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedPort != null)
+                {
+                    foreach (var item in poco.nestedPort)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedReference != null)
+                {
+                    foreach (var item in poco.nestedReference)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRendering != null)
+                {
+                    foreach (var item in poco.nestedRendering)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedRequirement != null)
+                {
+                    foreach (var item in poco.nestedRequirement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedState != null)
+                {
+                    foreach (var item in poco.nestedState)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedTransition != null)
+                {
+                    foreach (var item in poco.nestedTransition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUsage != null)
+                {
+                    foreach (var item in poco.nestedUsage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedUseCase != null)
+                {
+                    foreach (var item in poco.nestedUseCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedVerificationCase != null)
+                {
+                    foreach (var item in poco.nestedVerificationCase)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedView != null)
+                {
+                    foreach (var item in poco.nestedView)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.nestedViewpoint != null)
+                {
+                    foreach (var item in poco.nestedViewpoint)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.occurrenceDefinition != null)
+                {
+                    foreach (var item in poco.occurrenceDefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.output != null)
+                {
+                    foreach (var item in poco.output)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedAnnotation != null)
+                {
+                    foreach (var item in poco.ownedAnnotation)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedConjugator != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedCrossSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDifferencing != null)
+                {
+                    foreach (var item in poco.ownedDifferencing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedDisjoining != null)
+                {
+                    foreach (var item in poco.ownedDisjoining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedElement != null)
+                {
+                    foreach (var item in poco.ownedElement)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedEndFeature != null)
+                {
+                    foreach (var item in poco.ownedEndFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeature != null)
+                {
+                    foreach (var item in poco.ownedFeature)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureChaining != null)
+                {
+                    foreach (var item in poco.ownedFeatureChaining)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureInverting != null)
+                {
+                    foreach (var item in poco.ownedFeatureInverting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedFeatureMembership != null)
+                {
+                    foreach (var item in poco.ownedFeatureMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedImport != null)
+                {
+                    foreach (var item in poco.ownedImport)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedIntersecting != null)
+                {
+                    foreach (var item in poco.ownedIntersecting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMember != null)
+                {
+                    foreach (var item in poco.ownedMember)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedMembership != null)
+                {
+                    foreach (var item in poco.ownedMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedRedefinition != null)
+                {
+                    foreach (var item in poco.ownedRedefinition)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedReferenceSubsetting != null)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwnedRelationship != null)
+            {
+                foreach (var item in poco.OwnedRelationship)
+                {
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSpecialization != null)
+                {
+                    foreach (var item in poco.ownedSpecialization)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedSubsetting != null)
+                {
+                    foreach (var item in poco.ownedSubsetting)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTypeFeaturing != null)
+                {
+                    foreach (var item in poco.ownedTypeFeaturing)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedTyping != null)
+                {
+                    foreach (var item in poco.ownedTyping)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.ownedUnioning != null)
+                {
+                    foreach (var item in poco.ownedUnioning)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owner != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningDefinition != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningFeatureMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningMembership != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningNamespace != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (poco.OwningRelationship != null)
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningType != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.owningUsage != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.parameter != null)
+                {
+                    foreach (var item in poco.parameter)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.textualRepresentation != null)
+                {
+                    foreach (var item in poco.textualRepresentation)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.unioningType != null)
+                {
+                    foreach (var item in poco.unioningType)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.untilArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.untilArgument, "untilArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.usage != null)
+                {
+                    foreach (var item in poco.usage)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variant != null)
+                {
+                    foreach (var item in poco.variant)
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.variantMembership != null)
+                {
+                    foreach (var item in poco.variantMembership)
+                    {
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    }
+                }
+            }
+
+            if (includeDerivedProperties)
+            {
+                if (poco.whileArgument != null)
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.whileArgument, "whileArgument", elementOriginMap, currentFileUri);
+                }
+            }
+
+
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
index ee768865d..4e12c4fc8 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
@@ -26,363 +26,1719 @@ namespace SysML2.NET.Serializer.Xmi.Writers
 {
     using System;
     using System.Collections.Generic;
+    using System.Threading.Tasks;
     using System.Xml;
 
+    using Microsoft.Extensions.Logging;
+
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="XmiDataWriterFacade"/> is to dispatch writing of <see cref="IData"/> instances
-    /// to the appropriate per-type static writer class
+    /// to the appropriate per-type writer class
     /// </summary>
     public class XmiDataWriterFacade : IXmiDataWriterFacade
     {
+        /// <summary>
+        /// The <see cref="ILoggerFactory"/> used to set up logging for writer instances
+        /// </summary>
+        private readonly ILoggerFactory loggerFactory;
+
         /// <summary>
         /// A dictionary that contains actions that write <see cref="IData"/> based on a key that represents the POCO type name
         /// </summary>
-        private readonly Dictionary<string, Action<XmlWriter, IData, string, bool, IXmiDataWriterFacade, IXmiElementOriginMap, Uri>> writerCache;
+        private readonly Dictionary<string, Action<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri>> writerCache;
+
+        /// <summary>
+        /// A dictionary that contains functions that asynchronously write <see cref="IData"/> based on a key that represents the POCO type name
+        /// </summary>
+        private readonly Dictionary<string, Func<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri, Task>> writerAsyncCache;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="XmiDataWriterFacade"/>
         /// </summary>
-        public XmiDataWriterFacade()
+        /// <param name="loggerFactory">The <see cref="ILoggerFactory"/> used to set up logging</param>
+        public XmiDataWriterFacade(ILoggerFactory loggerFactory)
         {
-            this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, bool, IXmiDataWriterFacade, IXmiElementOriginMap, Uri>>
+            this.loggerFactory = loggerFactory;
+
+            this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri>>
             {
-                ["AcceptActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AcceptActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["ActionDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ActionDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["ActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["ActorMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ActorMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["AllocationDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AllocationDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["AllocationUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AllocationUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["AnalysisCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AnalysisCaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["AnalysisCaseUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AnalysisCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["AnnotatingElement"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AnnotatingElementWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, includeDerived, facade, originMap, uri),
-                ["Annotation"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AnnotationWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, includeDerived, facade, originMap, uri),
-                ["AssertConstraintUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AssertConstraintUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["AssignmentActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AssignmentActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["Association"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AssociationWriter.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, includeDerived, facade, originMap, uri),
-                ["AssociationStructure"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AssociationStructureWriter.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, includeDerived, facade, originMap, uri),
-                ["AttributeDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AttributeDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["AttributeUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    AttributeUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["Behavior"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    BehaviorWriter.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, includeDerived, facade, originMap, uri),
-                ["BindingConnector"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    BindingConnectorWriter.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, includeDerived, facade, originMap, uri),
-                ["BindingConnectorAsUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    BindingConnectorAsUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["BooleanExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    BooleanExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["CalculationDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    CalculationDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["CalculationUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    CalculationUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["CaseDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    CaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["CaseUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    CaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["Class"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ClassWriter.Write(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, includeDerived, facade, originMap, uri),
-                ["Classifier"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ClassifierWriter.Write(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, includeDerived, facade, originMap, uri),
-                ["CollectExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    CollectExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["Comment"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    CommentWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, includeDerived, facade, originMap, uri),
-                ["ConcernDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConcernDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["ConcernUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConcernUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["ConjugatedPortDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConjugatedPortDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["ConjugatedPortTyping"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConjugatedPortTypingWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, includeDerived, facade, originMap, uri),
-                ["Conjugation"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConjugationWriter.Write(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, includeDerived, facade, originMap, uri),
-                ["ConnectionDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConnectionDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["ConnectionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConnectionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["Connector"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConnectorWriter.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, includeDerived, facade, originMap, uri),
-                ["ConstraintDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConstraintDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["ConstraintUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConstraintUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["ConstructorExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ConstructorExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["CrossSubsetting"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    CrossSubsettingWriter.Write(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, includeDerived, facade, originMap, uri),
-                ["DataType"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    DataTypeWriter.Write(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, includeDerived, facade, originMap, uri),
-                ["DecisionNode"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    DecisionNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, includeDerived, facade, originMap, uri),
-                ["Definition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    DefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["Dependency"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    DependencyWriter.Write(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, includeDerived, facade, originMap, uri),
-                ["Differencing"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    DifferencingWriter.Write(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, includeDerived, facade, originMap, uri),
-                ["Disjoining"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    DisjoiningWriter.Write(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, includeDerived, facade, originMap, uri),
-                ["Documentation"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    DocumentationWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, includeDerived, facade, originMap, uri),
-                ["ElementFilterMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ElementFilterMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["EndFeatureMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    EndFeatureMembershipWriter.Write(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["EnumerationDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    EnumerationDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["EnumerationUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    EnumerationUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["EventOccurrenceUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    EventOccurrenceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["ExhibitStateUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ExhibitStateUsageWriter.Write(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["Expression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["Feature"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FeatureWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, includeDerived, facade, originMap, uri),
-                ["FeatureChainExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FeatureChainExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["FeatureChaining"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FeatureChainingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, includeDerived, facade, originMap, uri),
-                ["FeatureInverting"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FeatureInvertingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, includeDerived, facade, originMap, uri),
-                ["FeatureMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FeatureMembershipWriter.Write(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["FeatureReferenceExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FeatureReferenceExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["FeatureTyping"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FeatureTypingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, includeDerived, facade, originMap, uri),
-                ["FeatureValue"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FeatureValueWriter.Write(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, includeDerived, facade, originMap, uri),
-                ["Flow"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FlowWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, includeDerived, facade, originMap, uri),
-                ["FlowDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FlowDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["FlowEnd"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FlowEndWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, includeDerived, facade, originMap, uri),
-                ["FlowUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FlowUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["ForkNode"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ForkNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, includeDerived, facade, originMap, uri),
-                ["ForLoopActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ForLoopActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["FramedConcernMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FramedConcernMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["Function"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    FunctionWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, includeDerived, facade, originMap, uri),
-                ["IfActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    IfActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["IncludeUseCaseUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    IncludeUseCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["IndexExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    IndexExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["Interaction"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    InteractionWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, includeDerived, facade, originMap, uri),
-                ["InterfaceDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    InterfaceDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["InterfaceUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    InterfaceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["Intersecting"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    IntersectingWriter.Write(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, includeDerived, facade, originMap, uri),
-                ["Invariant"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    InvariantWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, includeDerived, facade, originMap, uri),
-                ["InvocationExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    InvocationExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["ItemDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ItemDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["ItemUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ItemUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["JoinNode"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    JoinNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, includeDerived, facade, originMap, uri),
-                ["LibraryPackage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    LibraryPackageWriter.Write(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, includeDerived, facade, originMap, uri),
-                ["LiteralBoolean"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    LiteralBooleanWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, includeDerived, facade, originMap, uri),
-                ["LiteralExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    LiteralExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["LiteralInfinity"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    LiteralInfinityWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, includeDerived, facade, originMap, uri),
-                ["LiteralInteger"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    LiteralIntegerWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, includeDerived, facade, originMap, uri),
-                ["LiteralRational"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    LiteralRationalWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, includeDerived, facade, originMap, uri),
-                ["LiteralString"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    LiteralStringWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, includeDerived, facade, originMap, uri),
-                ["Membership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MembershipWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["MembershipExpose"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MembershipExposeWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, includeDerived, facade, originMap, uri),
-                ["MembershipImport"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MembershipImportWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, includeDerived, facade, originMap, uri),
-                ["MergeNode"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MergeNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, includeDerived, facade, originMap, uri),
-                ["Metaclass"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MetaclassWriter.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, includeDerived, facade, originMap, uri),
-                ["MetadataAccessExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MetadataAccessExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["MetadataDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MetadataDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["MetadataFeature"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MetadataFeatureWriter.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, includeDerived, facade, originMap, uri),
-                ["MetadataUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MetadataUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["Multiplicity"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MultiplicityWriter.Write(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, includeDerived, facade, originMap, uri),
-                ["MultiplicityRange"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    MultiplicityRangeWriter.Write(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, includeDerived, facade, originMap, uri),
-                ["Namespace"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    NamespaceWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, includeDerived, facade, originMap, uri),
-                ["NamespaceExpose"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    NamespaceExposeWriter.Write(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, includeDerived, facade, originMap, uri),
-                ["NamespaceImport"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    NamespaceImportWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, includeDerived, facade, originMap, uri),
-                ["NullExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    NullExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["ObjectiveMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ObjectiveMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["OccurrenceDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    OccurrenceDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["OccurrenceUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    OccurrenceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["OperatorExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    OperatorExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["OwningMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    OwningMembershipWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["Package"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    PackageWriter.Write(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, includeDerived, facade, originMap, uri),
-                ["ParameterMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ParameterMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["PartDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    PartDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["PartUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    PartUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["PayloadFeature"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    PayloadFeatureWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, includeDerived, facade, originMap, uri),
-                ["PerformActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    PerformActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["PortConjugation"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    PortConjugationWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, includeDerived, facade, originMap, uri),
-                ["PortDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    PortDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["PortUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    PortUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["Predicate"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    PredicateWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, includeDerived, facade, originMap, uri),
-                ["Redefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    RedefinitionWriter.Write(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["ReferenceSubsetting"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ReferenceSubsettingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, includeDerived, facade, originMap, uri),
-                ["ReferenceUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ReferenceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["RenderingDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    RenderingDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["RenderingUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    RenderingUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["RequirementConstraintMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    RequirementConstraintMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["RequirementDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    RequirementDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["RequirementUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    RequirementUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["RequirementVerificationMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    RequirementVerificationMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["ResultExpressionMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ResultExpressionMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["ReturnParameterMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ReturnParameterMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["SatisfyRequirementUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SatisfyRequirementUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["SelectExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SelectExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["SendActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SendActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["Specialization"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SpecializationWriter.Write(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, includeDerived, facade, originMap, uri),
-                ["StakeholderMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    StakeholderMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["StateDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    StateDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["StateSubactionMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    StateSubactionMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["StateUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    StateUsageWriter.Write(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["Step"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    StepWriter.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, includeDerived, facade, originMap, uri),
-                ["Structure"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    StructureWriter.Write(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, includeDerived, facade, originMap, uri),
-                ["Subclassification"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SubclassificationWriter.Write(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, includeDerived, facade, originMap, uri),
-                ["SubjectMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SubjectMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["Subsetting"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SubsettingWriter.Write(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, includeDerived, facade, originMap, uri),
-                ["Succession"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SuccessionWriter.Write(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, includeDerived, facade, originMap, uri),
-                ["SuccessionAsUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SuccessionAsUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["SuccessionFlow"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SuccessionFlowWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, includeDerived, facade, originMap, uri),
-                ["SuccessionFlowUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    SuccessionFlowUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["TerminateActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    TerminateActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["TextualRepresentation"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    TextualRepresentationWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, includeDerived, facade, originMap, uri),
-                ["TransitionFeatureMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    TransitionFeatureMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["TransitionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    TransitionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["TriggerInvocationExpression"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    TriggerInvocationExpressionWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, includeDerived, facade, originMap, uri),
-                ["Type"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    TypeWriter.Write(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, includeDerived, facade, originMap, uri),
-                ["TypeFeaturing"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    TypeFeaturingWriter.Write(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, includeDerived, facade, originMap, uri),
-                ["Unioning"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    UnioningWriter.Write(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, includeDerived, facade, originMap, uri),
-                ["Usage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    UsageWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["UseCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    UseCaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["UseCaseUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    UseCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["VariantMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    VariantMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["VerificationCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    VerificationCaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["VerificationCaseUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    VerificationCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["ViewDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ViewDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["ViewpointDefinition"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ViewpointDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, includeDerived, facade, originMap, uri),
-                ["ViewpointUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ViewpointUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["ViewRenderingMembership"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ViewRenderingMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, includeDerived, facade, originMap, uri),
-                ["ViewUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    ViewUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, includeDerived, facade, originMap, uri),
-                ["WhileLoopActionUsage"] = (xmlWriter, data, elementName, includeDerived, facade, originMap, uri) =>
-                    WhileLoopActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, includeDerived, facade, originMap, uri),
+                ["AcceptActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AcceptActionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ActionDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ActionDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ActionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ActorMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ActorMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AllocationDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AllocationDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AllocationUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AllocationUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AnalysisCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AnalysisCaseDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AnalysisCaseUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AnalysisCaseUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AnnotatingElement"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AnnotatingElementWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Annotation"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AnnotationWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AssertConstraintUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AssertConstraintUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AssignmentActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AssignmentActionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Association"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AssociationWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AssociationStructure"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AssociationStructureWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AttributeDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AttributeDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AttributeUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AttributeUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Behavior"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new BehaviorWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["BindingConnector"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new BindingConnectorWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["BindingConnectorAsUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new BindingConnectorAsUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["BooleanExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new BooleanExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CalculationDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CalculationDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CalculationUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CalculationUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CaseDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CaseDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CaseUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CaseUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Class"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ClassWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Classifier"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ClassifierWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CollectExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CollectExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Comment"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CommentWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConcernDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConcernDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConcernUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConcernUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConjugatedPortDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConjugatedPortDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConjugatedPortTyping"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConjugatedPortTypingWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Conjugation"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConjugationWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConnectionDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConnectionDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConnectionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConnectionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Connector"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConnectorWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConstraintDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConstraintDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConstraintUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConstraintUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConstructorExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConstructorExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CrossSubsetting"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CrossSubsettingWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["DataType"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DataTypeWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["DecisionNode"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DecisionNodeWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Definition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Dependency"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DependencyWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Differencing"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DifferencingWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Disjoining"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DisjoiningWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Documentation"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DocumentationWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ElementFilterMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ElementFilterMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["EndFeatureMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new EndFeatureMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["EnumerationDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new EnumerationDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["EnumerationUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new EnumerationUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["EventOccurrenceUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new EventOccurrenceUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ExhibitStateUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ExhibitStateUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Expression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Feature"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureChainExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureChainExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureChaining"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureChainingWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureInverting"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureInvertingWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureReferenceExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureReferenceExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureTyping"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureTypingWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureValue"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureValueWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Flow"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FlowWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FlowDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FlowDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FlowEnd"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FlowEndWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FlowUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FlowUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ForkNode"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ForkNodeWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ForLoopActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ForLoopActionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FramedConcernMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FramedConcernMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Function"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FunctionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["IfActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new IfActionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["IncludeUseCaseUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new IncludeUseCaseUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["IndexExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new IndexExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Interaction"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new InteractionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["InterfaceDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new InterfaceDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["InterfaceUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new InterfaceUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Intersecting"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new IntersectingWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Invariant"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new InvariantWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["InvocationExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new InvocationExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ItemDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ItemDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ItemUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ItemUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["JoinNode"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new JoinNodeWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LibraryPackage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LibraryPackageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralBoolean"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralBooleanWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralInfinity"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralInfinityWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralInteger"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralIntegerWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralRational"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralRationalWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralString"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralStringWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Membership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MembershipExpose"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MembershipExposeWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MembershipImport"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MembershipImportWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MergeNode"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MergeNodeWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Metaclass"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MetaclassWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MetadataAccessExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MetadataAccessExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MetadataDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MetadataDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MetadataFeature"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MetadataFeatureWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MetadataUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MetadataUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Multiplicity"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MultiplicityWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MultiplicityRange"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MultiplicityRangeWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Namespace"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new NamespaceWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["NamespaceExpose"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new NamespaceExposeWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["NamespaceImport"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new NamespaceImportWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["NullExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new NullExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ObjectiveMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ObjectiveMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["OccurrenceDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new OccurrenceDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["OccurrenceUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new OccurrenceUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["OperatorExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new OperatorExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["OwningMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new OwningMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Package"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PackageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ParameterMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ParameterMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PartDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PartDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PartUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PartUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PayloadFeature"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PayloadFeatureWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PerformActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PerformActionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PortConjugation"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PortConjugationWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PortDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PortDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PortUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PortUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Predicate"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PredicateWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Redefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RedefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ReferenceSubsetting"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ReferenceSubsettingWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ReferenceUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ReferenceUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RenderingDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RenderingDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RenderingUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RenderingUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RequirementConstraintMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RequirementConstraintMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RequirementDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RequirementDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RequirementUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RequirementUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RequirementVerificationMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RequirementVerificationMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ResultExpressionMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ResultExpressionMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ReturnParameterMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ReturnParameterMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SatisfyRequirementUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SatisfyRequirementUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SelectExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SelectExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SendActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SendActionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Specialization"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SpecializationWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["StakeholderMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StakeholderMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["StateDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StateDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["StateSubactionMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StateSubactionMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["StateUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StateUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Step"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StepWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Structure"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StructureWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Subclassification"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SubclassificationWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SubjectMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SubjectMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Subsetting"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SubsettingWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Succession"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SuccessionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SuccessionAsUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SuccessionAsUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SuccessionFlow"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SuccessionFlowWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SuccessionFlowUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SuccessionFlowUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TerminateActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TerminateActionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TextualRepresentation"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TextualRepresentationWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TransitionFeatureMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TransitionFeatureMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TransitionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TransitionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TriggerInvocationExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TriggerInvocationExpressionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Type"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TypeWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TypeFeaturing"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TypeFeaturingWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Unioning"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new UnioningWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Usage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new UsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["UseCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new UseCaseDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["UseCaseUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new UseCaseUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["VariantMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new VariantMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["VerificationCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new VerificationCaseDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["VerificationCaseUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new VerificationCaseUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ViewDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ViewDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ViewpointDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ViewpointDefinitionWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ViewpointUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ViewpointUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ViewRenderingMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ViewRenderingMembershipWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ViewUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ViewUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["WhileLoopActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new WhileLoopActionUsageWriter(this, this.loggerFactory);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+            };
+
+            this.writerAsyncCache = new Dictionary<string, Func<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri, Task>>
+            {
+                ["AcceptActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AcceptActionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ActionDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ActionDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ActionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ActorMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ActorMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AllocationDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AllocationDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AllocationUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AllocationUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AnalysisCaseDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AnalysisCaseDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AnalysisCaseUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AnalysisCaseUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AnnotatingElement"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AnnotatingElementWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Annotation"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AnnotationWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AssertConstraintUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AssertConstraintUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AssignmentActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AssignmentActionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Association"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AssociationWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AssociationStructure"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AssociationStructureWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AttributeDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AttributeDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["AttributeUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new AttributeUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Behavior"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new BehaviorWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["BindingConnector"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new BindingConnectorWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["BindingConnectorAsUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new BindingConnectorAsUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["BooleanExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new BooleanExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CalculationDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CalculationDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CalculationUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CalculationUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CaseDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CaseDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CaseUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CaseUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Class"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ClassWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Classifier"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ClassifierWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CollectExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CollectExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Comment"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CommentWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConcernDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConcernDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConcernUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConcernUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConjugatedPortDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConjugatedPortDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConjugatedPortTyping"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConjugatedPortTypingWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Conjugation"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConjugationWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConnectionDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConnectionDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConnectionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConnectionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Connector"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConnectorWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConstraintDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConstraintDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConstraintUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConstraintUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ConstructorExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ConstructorExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["CrossSubsetting"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new CrossSubsettingWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["DataType"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DataTypeWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["DecisionNode"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DecisionNodeWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Definition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Dependency"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DependencyWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Differencing"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DifferencingWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Disjoining"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DisjoiningWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Documentation"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new DocumentationWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ElementFilterMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ElementFilterMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["EndFeatureMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new EndFeatureMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["EnumerationDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new EnumerationDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["EnumerationUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new EnumerationUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["EventOccurrenceUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new EventOccurrenceUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ExhibitStateUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ExhibitStateUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Expression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Feature"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureChainExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureChainExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureChaining"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureChainingWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureInverting"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureInvertingWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureReferenceExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureReferenceExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureTyping"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureTypingWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FeatureValue"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FeatureValueWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Flow"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FlowWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FlowDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FlowDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FlowEnd"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FlowEndWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FlowUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FlowUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ForkNode"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ForkNodeWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ForLoopActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ForLoopActionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["FramedConcernMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FramedConcernMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Function"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new FunctionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["IfActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new IfActionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["IncludeUseCaseUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new IncludeUseCaseUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["IndexExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new IndexExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Interaction"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new InteractionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["InterfaceDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new InterfaceDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["InterfaceUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new InterfaceUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Intersecting"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new IntersectingWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Invariant"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new InvariantWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["InvocationExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new InvocationExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ItemDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ItemDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ItemUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ItemUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["JoinNode"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new JoinNodeWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LibraryPackage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LibraryPackageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralBoolean"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralBooleanWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralInfinity"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralInfinityWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralInteger"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralIntegerWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralRational"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralRationalWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["LiteralString"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new LiteralStringWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Membership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MembershipExpose"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MembershipExposeWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MembershipImport"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MembershipImportWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MergeNode"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MergeNodeWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Metaclass"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MetaclassWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MetadataAccessExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MetadataAccessExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MetadataDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MetadataDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MetadataFeature"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MetadataFeatureWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MetadataUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MetadataUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Multiplicity"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MultiplicityWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["MultiplicityRange"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new MultiplicityRangeWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Namespace"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new NamespaceWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["NamespaceExpose"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new NamespaceExposeWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["NamespaceImport"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new NamespaceImportWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["NullExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new NullExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ObjectiveMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ObjectiveMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["OccurrenceDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new OccurrenceDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["OccurrenceUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new OccurrenceUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["OperatorExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new OperatorExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["OwningMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new OwningMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Package"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PackageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ParameterMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ParameterMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PartDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PartDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PartUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PartUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PayloadFeature"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PayloadFeatureWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PerformActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PerformActionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PortConjugation"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PortConjugationWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PortDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PortDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["PortUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PortUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Predicate"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new PredicateWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Redefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RedefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ReferenceSubsetting"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ReferenceSubsettingWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ReferenceUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ReferenceUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RenderingDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RenderingDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RenderingUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RenderingUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RequirementConstraintMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RequirementConstraintMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RequirementDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RequirementDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RequirementUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RequirementUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["RequirementVerificationMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new RequirementVerificationMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ResultExpressionMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ResultExpressionMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ReturnParameterMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ReturnParameterMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SatisfyRequirementUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SatisfyRequirementUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SelectExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SelectExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SendActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SendActionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Specialization"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SpecializationWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["StakeholderMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StakeholderMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["StateDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StateDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["StateSubactionMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StateSubactionMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["StateUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StateUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Step"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StepWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Structure"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new StructureWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Subclassification"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SubclassificationWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SubjectMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SubjectMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Subsetting"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SubsettingWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Succession"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SuccessionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SuccessionAsUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SuccessionAsUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SuccessionFlow"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SuccessionFlowWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["SuccessionFlowUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new SuccessionFlowUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TerminateActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TerminateActionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TextualRepresentation"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TextualRepresentationWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TransitionFeatureMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TransitionFeatureMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TransitionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TransitionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TriggerInvocationExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TriggerInvocationExpressionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Type"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TypeWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["TypeFeaturing"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new TypeFeaturingWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Unioning"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new UnioningWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["Usage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new UsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["UseCaseDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new UseCaseDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["UseCaseUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new UseCaseUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["VariantMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new VariantMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["VerificationCaseDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new VerificationCaseDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["VerificationCaseUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new VerificationCaseUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ViewDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ViewDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ViewpointDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ViewpointDefinitionWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ViewpointUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ViewpointUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ViewRenderingMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ViewRenderingMembershipWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["ViewUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new ViewUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
+                ["WhileLoopActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                {
+                    var writer = new WhileLoopActionUsageWriter(this, this.loggerFactory);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                },
             };
         }
 
@@ -395,13 +1751,13 @@ public XmiDataWriterFacade()
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             var typeName = data.GetType().Name;
 
             if (this.writerCache.TryGetValue(typeName, out var writer))
             {
-                writer(xmlWriter, data, elementName, includeDerivedProperties, this, elementOriginMap, currentFileUri);
+                writer(xmlWriter, data, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
             }
             else
             {
@@ -418,8 +1774,13 @@ public void Write(XmlWriter xmlWriter, IData data, string elementName, bool incl
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
         {
+            if (!includesImplied && childData is IRelationship rel && rel.IsImplied)
+            {
+                return;
+            }
+
             if (elementOriginMap != null && currentFileUri != null)
             {
                 var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
@@ -431,7 +1792,7 @@ public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string e
                 }
             }
 
-            this.Write(xmlWriter, childData, elementName, includeDerivedProperties, elementOriginMap, currentFileUri);
+            this.Write(xmlWriter, childData, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
         }
 
         /// <summary>
@@ -460,6 +1821,85 @@ public void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string e
             xmlWriter.WriteEndElement();
         }
 
+        /// <summary>
+        /// Asynchronously writes the specified <see cref="IData"/> as an XMI element by dispatching to the appropriate per-type writer
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="data">The <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public async Task WriteAsync(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        {
+            var typeName = data.GetType().Name;
+
+            if (this.writerAsyncCache.TryGetValue(typeName, out var writer))
+            {
+                await writer(xmlWriter, data, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+            }
+            else
+            {
+                throw new InvalidOperationException($"No writer found for type {typeName}");
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously writes a contained child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public async Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (!includesImplied && childData is IRelationship rel && rel.IsImplied)
+            {
+                return;
+            }
+
+            if (elementOriginMap != null && currentFileUri != null)
+            {
+                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
+
+                if (childSourceFile != null && childSourceFile != currentFileUri)
+                {
+                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    return;
+                }
+            }
+
+            await this.WriteAsync(xmlWriter, childData, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a reference child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        public async Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (elementOriginMap != null && currentFileUri != null)
+            {
+                var childSourceFile = elementOriginMap.GetSourceFile(childData.Id);
+
+                if (childSourceFile != null && childSourceFile != currentFileUri)
+                {
+                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    return;
+                }
+            }
+
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync("xmi", "idref", null, childData.Id.ToString());
+            await xmlWriter.WriteEndElementAsync();
+        }
+
         /// <summary>
         /// Writes an href element for cross-file references
         /// </summary>
@@ -472,6 +1912,19 @@ private static void WriteHrefElement(XmlWriter xmlWriter, IData childData, strin
             xmlWriter.WriteAttributeString("href", href);
             xmlWriter.WriteEndElement();
         }
+
+        /// <summary>
+        /// Asynchronously writes an href element for cross-file references
+        /// </summary>
+        private static async Task WriteHrefElementAsync(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile)
+        {
+            var relativePath = currentFile.MakeRelativeUri(targetFile);
+            var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{childData.Id}";
+
+            await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            await xmlWriter.WriteAttributeStringAsync(null, "href", null, href);
+            await xmlWriter.WriteEndElementAsync();
+        }
     }
 }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs b/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs
index 3b3f25508..eadc840b3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs
@@ -21,6 +21,7 @@
 namespace SysML2.NET.Serializer.Xmi.Writers
 {
     using System;
+    using System.Threading.Tasks;
     using System.Xml;
 
     using SysML2.NET.Common;
@@ -38,9 +39,10 @@ public interface IXmiDataWriterFacade
         /// <param name="data">The <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">Whether implied relationships and isImpliedIncluded attributes are serialized</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null);
+        void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null);
 
         /// <summary>
         /// Writes a contained child element, checking origin map for cross-file href
@@ -49,9 +51,10 @@ public interface IXmiDataWriterFacade
         /// <param name="childData">The child <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
         /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">Whether implied relationships and isImpliedIncluded attributes are serialized</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+        void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
 
         /// <summary>
         /// Writes a reference child element, checking origin map for cross-file href
@@ -62,5 +65,39 @@ public interface IXmiDataWriterFacade
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
         void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+
+        /// <summary>
+        /// Asynchronously writes the specified <see cref="IData"/> as an XMI element by dispatching to the appropriate per-type writer
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="data">The <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">Whether implied relationships and isImpliedIncluded attributes are serialized</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        Task WriteAsync(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null);
+
+        /// <summary>
+        /// Asynchronously writes a contained child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">Whether implied relationships and isImpliedIncluded attributes are serialized</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+
+        /// <summary>
+        /// Asynchronously writes a reference child element, checking origin map for cross-file href
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
+        /// <param name="childData">The child <see cref="IData"/> to write</param>
+        /// <param name="elementName">The XML element name to use</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
+        Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/XmiDataWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/XmiDataWriter.cs
new file mode 100644
index 000000000..f38922fb2
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/XmiDataWriter.cs
@@ -0,0 +1,101 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="XmiDataWriter.cs" company="Starion Group S.A.">
+//
+//   Copyright 2022-2026 Starion Group S.A.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    using System;
+    using System.Threading.Tasks;
+    using System.Xml;
+
+    using Microsoft.Extensions.Logging;
+
+    using SysML2.NET.Common;
+
+    /// <summary>
+    /// Abstract super class for each XMI writer
+    /// </summary>
+    /// <typeparam name="TData">The type of <see cref="IData" /> that needs to be written</typeparam>
+    public abstract class XmiDataWriter<TData> where TData : IData
+    {
+        /// <summary>
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </summary>
+        protected readonly IXmiDataWriterFacade XmiDataWriterFacade;
+
+        /// <summary>
+        /// The injected <see cref="ILoggerFactory" /> used to set up logging
+        /// </summary>
+        protected readonly ILoggerFactory LoggerFactory;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="XmiDataWriter{TData}" />
+        /// </summary>
+        /// <param name="xmiDataWriterFacade">
+        /// The injected <see cref="IXmiDataWriterFacade" /> that provides dispatch to per-type writers
+        /// </param>
+        /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        protected XmiDataWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory loggerFactory)
+        {
+            this.XmiDataWriterFacade = xmiDataWriterFacade;
+            this.LoggerFactory = loggerFactory;
+        }
+
+        /// <summary>
+        /// Writes the <typeparamref name="TData" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="data">The <typeparamref name="TData" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        public abstract void Write(XmlWriter xmlWriter, TData data, string elementName,
+            bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null,
+            Uri currentFileUri = null);
+
+        /// <summary>
+        /// Asynchronously writes the <typeparamref name="TData" /> object to its XML representation
+        /// </summary>
+        /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
+        /// <param name="data">The <typeparamref name="TData" /> to write</param>
+        /// <param name="elementName">The XML element name</param>
+        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="includesImplied">
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
+        /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
+        /// <returns>An awaitable <see cref="Task" /></returns>
+        public abstract Task WriteAsync(XmlWriter xmlWriter, TData data, string elementName,
+            bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null,
+            Uri currentFileUri = null);
+    }
+}

From 0ab30b3e069f417882364419a86d54e9e295319b Mon Sep 17 00:00:00 2001
From: atheate <a.theate@stariongroup.eu>
Date: Fri, 20 Mar 2026 11:16:19 +0100
Subject: [PATCH 6/9] Verification and Validation of identical content compared
 to Original file

---
 .../HandleBarHelpers/PropertyHelper.cs        |   75 +-
 ...r-partial-for-attribute-async-template.hbs |   86 +-
 ...-writer-partial-for-attribute-template.hbs |   90 +-
 ...ter-partial-for-element-async-template.hbs |   11 +-
 ...mi-writer-partial-for-element-template.hbs |   11 +-
 .../Uml/core-xmi-writer-facade-template.hbs   |   76 +-
 .../Uml/core-xmi-writer-template.hbs          |   63 +-
 .../RoundTripTestFixture.cs                   |  120 +-
 .../SerializerTestFixture.cs                  |   16 +-
 .../SysML2.NET.Serializer.Xmi.Tests.csproj    |    1 +
 .../Extensions/DataExtension.cs               |   55 +
 SysML2.NET.Serializer.Xmi/ISerializer.cs      |   44 +-
 SysML2.NET.Serializer.Xmi/Serializer.cs       |  109 +-
 .../AutoGenWriters/AcceptActionUsageWriter.cs | 1051 +++++++-----
 .../AutoGenWriters/ActionDefinitionWriter.cs  |  599 +++----
 .../AutoGenWriters/ActionUsageWriter.cs       |  961 ++++++-----
 .../AutoGenWriters/ActorMembershipWriter.cs   |  245 +--
 .../AllocationDefinitionWriter.cs             |  657 ++++----
 .../AutoGenWriters/AllocationUsageWriter.cs   | 1059 ++++++++-----
 .../AnalysisCaseDefinitionWriter.cs           |  741 +++++----
 .../AutoGenWriters/AnalysisCaseUsageWriter.cs | 1121 ++++++++-----
 .../AutoGenWriters/AnnotatingElementWriter.cs |  199 ++-
 .../AutoGenWriters/AnnotationWriter.cs        |  289 ++--
 .../AssertConstraintUsageWriter.cs            | 1049 +++++++-----
 .../AssignmentActionUsageWriter.cs            | 1051 +++++++-----
 .../AssociationStructureWriter.cs             |  453 +++---
 .../AutoGenWriters/AssociationWriter.cs       |  453 +++---
 .../AttributeDefinitionWriter.cs              |  587 +++----
 .../AutoGenWriters/AttributeUsageWriter.cs    |  923 ++++++-----
 .../Writers/AutoGenWriters/BehaviorWriter.cs  |  403 ++---
 .../BindingConnectorAsUsageWriter.cs          | 1007 +++++++-----
 .../AutoGenWriters/BindingConnectorWriter.cs  |  743 +++++----
 .../AutoGenWriters/BooleanExpressionWriter.cs |  721 ++++++---
 .../CalculationDefinitionWriter.cs            |  645 ++++----
 .../AutoGenWriters/CalculationUsageWriter.cs  | 1025 +++++++-----
 .../AutoGenWriters/CaseDefinitionWriter.cs    |  711 +++++----
 .../Writers/AutoGenWriters/CaseUsageWriter.cs | 1091 ++++++++-----
 .../Writers/AutoGenWriters/ClassWriter.cs     |  397 ++---
 .../AutoGenWriters/ClassifierWriter.cs        |  397 ++---
 .../AutoGenWriters/CollectExpressionWriter.cs |  771 +++++----
 .../Writers/AutoGenWriters/CommentWriter.cs   |  199 ++-
 .../AutoGenWriters/ConcernDefinitionWriter.cs |  697 ++++----
 .../AutoGenWriters/ConcernUsageWriter.cs      | 1083 ++++++++-----
 .../ConjugatedPortDefinitionWriter.cs         |  623 ++++----
 .../ConjugatedPortTypingWriter.cs             |  269 ++--
 .../AutoGenWriters/ConjugationWriter.cs       |  239 +--
 .../ConnectionDefinitionWriter.cs             |  651 ++++----
 .../AutoGenWriters/ConnectionUsageWriter.cs   | 1059 ++++++++-----
 .../Writers/AutoGenWriters/ConnectorWriter.cs |  743 +++++----
 .../ConstraintDefinitionWriter.cs             |  633 ++++----
 .../AutoGenWriters/ConstraintUsageWriter.cs   | 1019 +++++++-----
 .../ConstructorExpressionWriter.cs            |  757 +++++----
 .../AutoGenWriters/CrossSubsettingWriter.cs   |  211 ++-
 .../Writers/AutoGenWriters/DataTypeWriter.cs  |  397 ++---
 .../AutoGenWriters/DecisionNodeWriter.cs      |  961 ++++++-----
 .../AutoGenWriters/DefinitionWriter.cs        |  587 +++----
 .../AutoGenWriters/DependencyWriter.cs        |  191 ++-
 .../AutoGenWriters/DifferencingWriter.cs      |  219 ++-
 .../AutoGenWriters/DisjoiningWriter.cs        |  239 +--
 .../AutoGenWriters/DocumentationWriter.cs     |  221 +--
 .../ElementFilterMembershipWriter.cs          |  245 +--
 .../EndFeatureMembershipWriter.cs             |  245 +--
 .../EnumerationDefinitionWriter.cs            |  595 +++----
 .../AutoGenWriters/EnumerationUsageWriter.cs  |  947 ++++++-----
 .../EventOccurrenceUsageWriter.cs             |  993 +++++++-----
 .../AutoGenWriters/ExhibitStateUsageWriter.cs | 1089 ++++++++-----
 .../AutoGenWriters/ExpressionWriter.cs        |  721 ++++++---
 .../FeatureChainExpressionWriter.cs           |  801 ++++++----
 .../AutoGenWriters/FeatureChainingWriter.cs   |  219 ++-
 .../AutoGenWriters/FeatureInvertingWriter.cs  |  239 +--
 .../AutoGenWriters/FeatureMembershipWriter.cs |  245 +--
 .../FeatureReferenceExpressionWriter.cs       |  751 +++++----
 .../AutoGenWriters/FeatureTypingWriter.cs     |  239 +--
 .../AutoGenWriters/FeatureValueWriter.cs      |  275 ++--
 .../Writers/AutoGenWriters/FeatureWriter.cs   |  657 +++++---
 .../AutoGenWriters/FlowDefinitionWriter.cs    |  655 ++++----
 .../Writers/AutoGenWriters/FlowEndWriter.cs   |  657 +++++---
 .../Writers/AutoGenWriters/FlowUsageWriter.cs | 1155 +++++++++-----
 .../Writers/AutoGenWriters/FlowWriter.cs      |  845 ++++++----
 .../ForLoopActionUsageWriter.cs               | 1051 +++++++-----
 .../Writers/AutoGenWriters/ForkNodeWriter.cs  |  961 ++++++-----
 .../FramedConcernMembershipWriter.cs          |  285 ++--
 .../Writers/AutoGenWriters/FunctionWriter.cs  |  443 +++---
 .../AutoGenWriters/IfActionUsageWriter.cs     | 1051 +++++++-----
 .../IncludeUseCaseUsageWriter.cs              | 1135 ++++++++-----
 .../AutoGenWriters/IndexExpressionWriter.cs   |  771 +++++----
 .../AutoGenWriters/InteractionWriter.cs       |  459 +++---
 .../InterfaceDefinitionWriter.cs              |  651 ++++----
 .../AutoGenWriters/InterfaceUsageWriter.cs    | 1059 ++++++++-----
 .../AutoGenWriters/IntersectingWriter.cs      |  219 ++-
 .../Writers/AutoGenWriters/InvariantWriter.cs |  721 ++++++---
 .../InvocationExpressionWriter.cs             |  757 +++++----
 .../AutoGenWriters/ItemDefinitionWriter.cs    |  587 +++----
 .../Writers/AutoGenWriters/ItemUsageWriter.cs |  961 ++++++-----
 .../Writers/AutoGenWriters/JoinNodeWriter.cs  |  961 ++++++-----
 .../AutoGenWriters/LibraryPackageWriter.cs    |  211 +--
 .../AutoGenWriters/LiteralBooleanWriter.cs    |  721 ++++++---
 .../AutoGenWriters/LiteralExpressionWriter.cs |  721 ++++++---
 .../AutoGenWriters/LiteralInfinityWriter.cs   |  721 ++++++---
 .../AutoGenWriters/LiteralIntegerWriter.cs    |  721 ++++++---
 .../AutoGenWriters/LiteralRationalWriter.cs   |  721 ++++++---
 .../AutoGenWriters/LiteralStringWriter.cs     |  721 ++++++---
 .../AutoGenWriters/MembershipExposeWriter.cs  |  259 +--
 .../AutoGenWriters/MembershipImportWriter.cs  |  251 +--
 .../AutoGenWriters/MembershipWriter.cs        |  225 +--
 .../Writers/AutoGenWriters/MergeNodeWriter.cs |  961 ++++++-----
 .../Writers/AutoGenWriters/MetaclassWriter.cs |  397 ++---
 .../MetadataAccessExpressionWriter.cs         |  751 +++++----
 .../MetadataDefinitionWriter.cs               |  587 +++----
 .../AutoGenWriters/MetadataFeatureWriter.cs   |  725 +++++----
 .../AutoGenWriters/MetadataUsageWriter.cs     | 1029 +++++++-----
 .../AutoGenWriters/MultiplicityRangeWriter.cs |  723 ++++++---
 .../AutoGenWriters/MultiplicityWriter.cs      |  657 +++++---
 .../AutoGenWriters/NamespaceExposeWriter.cs   |  259 +--
 .../AutoGenWriters/NamespaceImportWriter.cs   |  251 +--
 .../Writers/AutoGenWriters/NamespaceWriter.cs |  205 +--
 .../AutoGenWriters/NullExpressionWriter.cs    |  721 ++++++---
 .../ObjectiveMembershipWriter.cs              |  245 +--
 .../OccurrenceDefinitionWriter.cs             |  587 +++----
 .../AutoGenWriters/OccurrenceUsageWriter.cs   |  955 ++++++-----
 .../OperatorExpressionWriter.cs               |  757 +++++----
 .../AutoGenWriters/OwningMembershipWriter.cs  |  245 +--
 .../Writers/AutoGenWriters/PackageWriter.cs   |  211 +--
 .../ParameterMembershipWriter.cs              |  245 +--
 .../AutoGenWriters/PartDefinitionWriter.cs    |  587 +++----
 .../Writers/AutoGenWriters/PartUsageWriter.cs |  967 +++++++-----
 .../AutoGenWriters/PayloadFeatureWriter.cs    |  657 +++++---
 .../PerformActionUsageWriter.cs               |  999 +++++++-----
 .../AutoGenWriters/PortConjugationWriter.cs   |  253 +--
 .../AutoGenWriters/PortDefinitionWriter.cs    |  617 ++++----
 .../Writers/AutoGenWriters/PortUsageWriter.cs |  955 ++++++-----
 .../Writers/AutoGenWriters/PredicateWriter.cs |  443 +++---
 .../AutoGenWriters/RedefinitionWriter.cs      |  235 +--
 .../ReferenceSubsettingWriter.cs              |  211 ++-
 .../AutoGenWriters/ReferenceUsageWriter.cs    |  923 ++++++-----
 .../RenderingDefinitionWriter.cs              |  593 +++----
 .../AutoGenWriters/RenderingUsageWriter.cs    |  991 +++++++-----
 .../RequirementConstraintMembershipWriter.cs  |  279 ++--
 .../RequirementDefinitionWriter.cs            |  697 ++++----
 .../AutoGenWriters/RequirementUsageWriter.cs  | 1083 ++++++++-----
 ...RequirementVerificationMembershipWriter.cs |  285 ++--
 .../ResultExpressionMembershipWriter.cs       |  245 +--
 .../ReturnParameterMembershipWriter.cs        |  245 +--
 .../SatisfyRequirementUsageWriter.cs          | 1143 +++++++++-----
 .../AutoGenWriters/SelectExpressionWriter.cs  |  771 +++++----
 .../AutoGenWriters/SendActionUsageWriter.cs   | 1051 +++++++-----
 .../AutoGenWriters/SpecializationWriter.cs    |  239 +--
 .../StakeholderMembershipWriter.cs            |  245 +--
 .../AutoGenWriters/StateDefinitionWriter.cs   |  695 ++++----
 .../StateSubactionMembershipWriter.cs         |  249 +--
 .../AutoGenWriters/StateUsageWriter.cs        | 1051 +++++++-----
 .../Writers/AutoGenWriters/StepWriter.cs      |  663 +++++---
 .../Writers/AutoGenWriters/StructureWriter.cs |  397 ++---
 .../AutoGenWriters/SubclassificationWriter.cs |  239 +--
 .../AutoGenWriters/SubjectMembershipWriter.cs |  245 +--
 .../AutoGenWriters/SubsettingWriter.cs        |  239 +--
 .../AutoGenWriters/SuccessionAsUsageWriter.cs | 1007 +++++++-----
 .../SuccessionFlowUsageWriter.cs              | 1155 +++++++++-----
 .../AutoGenWriters/SuccessionFlowWriter.cs    |  845 ++++++----
 .../AutoGenWriters/SuccessionWriter.cs        |  743 +++++----
 .../TerminateActionUsageWriter.cs             |  991 +++++++-----
 .../TextualRepresentationWriter.cs            |  221 +--
 .../TransitionFeatureMembershipWriter.cs      |  249 +--
 .../AutoGenWriters/TransitionUsageWriter.cs   | 1069 ++++++++-----
 .../TriggerInvocationExpressionWriter.cs      |  761 +++++----
 .../AutoGenWriters/TypeFeaturingWriter.cs     |  239 +--
 .../Writers/AutoGenWriters/TypeWriter.cs      |  389 +++--
 .../Writers/AutoGenWriters/UnioningWriter.cs  |  215 ++-
 .../Writers/AutoGenWriters/UsageWriter.cs     |  915 ++++++-----
 .../AutoGenWriters/UseCaseDefinitionWriter.cs |  717 +++++----
 .../AutoGenWriters/UseCaseUsageWriter.cs      | 1097 ++++++++-----
 .../AutoGenWriters/VariantMembershipWriter.cs |  245 +--
 .../VerificationCaseDefinitionWriter.cs       |  717 +++++----
 .../VerificationCaseUsageWriter.cs            | 1127 ++++++++-----
 .../AutoGenWriters/ViewDefinitionWriter.cs    |  635 ++++----
 .../ViewRenderingMembershipWriter.cs          |  275 ++--
 .../Writers/AutoGenWriters/ViewUsageWriter.cs | 1041 +++++++-----
 .../ViewpointDefinitionWriter.cs              |  703 +++++----
 .../AutoGenWriters/ViewpointUsageWriter.cs    | 1089 ++++++++-----
 .../WhileLoopActionUsageWriter.cs             | 1051 +++++++-----
 .../AutoGenWriters/XmiDataWriterFacade.cs     | 1404 +++++++++--------
 .../Writers/IXmiDataWriterFacade.cs           |   28 +-
 .../Writers/XmiDataWriter.cs                  |   22 +-
 .../Writers/XmiWriterOptions.cs               |   49 +
 184 files changed, 65032 insertions(+), 42991 deletions(-)
 create mode 100644 SysML2.NET.Serializer.Xmi/Extensions/DataExtension.cs
 create mode 100644 SysML2.NET.Serializer.Xmi/Writers/XmiWriterOptions.cs

diff --git a/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs b/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs
index 93eb6b4a3..f46a4c938 100644
--- a/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs
+++ b/SysML2.NET.CodeGenerator/HandleBarHelpers/PropertyHelper.cs
@@ -1047,7 +1047,80 @@ public static void RegisterPropertyHelper(this IHandlebars handlebars)
                 stringBuilder.AppendLine($"{childVariableName} => {childVariableName}.{oppositePropertyName});");
                 writer.WriteSafeString(stringBuilder + Environment.NewLine);
             });
-    }
+            
+            handlebars.RegisterHelper("Property.QueryHasDefaultValueWithDifferentValueThanDefault", (_, arguments) =>
+            {
+                if (arguments.Length != 1)
+                {
+                    throw new ArgumentException("The #Property.QueryHasDefaultValueWithDifferentValueThanDefault supposed to have one argument");
+                }
+
+                if (arguments[0] is not IProperty property)
+                {
+                    throw new ArgumentException("The #Property.QueryHasDefaultValueWithDifferentValueThanDefault argument supposed to be an IProperty");
+                }
+
+                return property.QueryIsEnum() 
+                    ? property.QueryIsEnumPropertyWithDefaultValue() 
+                    : (property.QueryHasDefaultValue() && property.QueryIsDefaultValueDifferentThanDefault());
+            });
+
+            handlebars.RegisterHelper("Property.WriteDefaultValue", (writer, _, arguments) =>
+            {
+                if (arguments.Length != 1)
+                {
+                    throw new ArgumentException("The #Property.WriteDefaultValue supposed to have one argument");
+                }
+
+                if (arguments[0] is not IProperty property)
+                {
+                    throw new ArgumentException("The #Property.WriteDefaultValue argument supposed to be an IProperty");
+                }
+
+                if (property.QueryIsEnum())
+                {
+                    writer.WriteSafeString($"{property.Type.Name}.{property.QueryDefaultValueAsString().CapitalizeFirstLetter()}");
+                }
+                else if (property.QueryIsString())
+                {
+                    writer.WriteSafeString($"\"{property.QueryDefaultValueAsString()}\"");
+                }
+                else
+                {
+                    writer.WriteSafeString($"{property.QueryDefaultValueAsString()}");
+                }
+            });
+            
+            handlebars.RegisterHelper("Property.QueryIsEnumerableAndReferenceProperty", (_, arguments) =>
+            {
+                if (arguments.Length != 1)
+                {
+                    throw new ArgumentException("The #Property.QueryIsEnumerableAndReferenceProperty supposed to have one argument");
+                }
+
+                if (arguments[0] is not IProperty property)
+                {
+                    throw new ArgumentException("The #Property.QueryIsEnumerableAndReferenceProperty argument supposed to be an IProperty");
+                }
+                
+                return property.QueryIsEnumerable() && property.QueryIsReferenceProperty();
+            });
+
+            handlebars.RegisterHelper("Property.IsTypeAbstract", (_, arguments) =>
+            {
+                if (arguments.Length != 1)
+                {
+                    throw new ArgumentException("The #Property.IsTypeAbstract supposed to have one argument");
+                }
+
+                if (arguments[0] is not IProperty property)
+                {
+                    throw new ArgumentException("The #Property.IsTypeAbstract argument supposed to be an IProperty");
+                }
+
+                return property.Type is IClassifier { IsAbstract: true };
+            });
+        }
 
         /// <summary>
         /// Gets the getter implementation for an <see cref="IProperty"/> that has been redefined, for DTO generation
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-async-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-async-template.hbs
index 55ec70b8f..60e66b15f 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-async-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-async-template.hbs
@@ -1,36 +1,70 @@
 {{#if (Property.QueryIsEnumerable property)}}
-    {{#if (Property.QueryIsBool property)}}
-        if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
-        {
+    {{#unless (Property.QueryIsReferenceProperty property)}}
+        {{#if (Property.QueryIsBool property)}}
+            if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
+            {
             await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, string.Join(" ", poco.{{Property.WritePropertyName property}}));
-        }
-    {{else}}
-        if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
-        {
+            }
+        {{else}}
+            if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
+            {
             await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, string.Join(" ", poco.{{Property.WritePropertyName property}}));
-        }
-    {{/if}}
+            }
+        {{/if}}
+    {{/unless}}
 {{else}}
-    {{#if (Property.QueryIsBool property)}}
-        {{#if (Property.QueryIsImpliedIncluded property)}}
-        if(includesImplied || poco.IsImpliedIncluded)
+    {{#if  (Property.QueryIsReferenceProperty property)}}
+        if(writerOptions.WriteIdRefAsAttribute && poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.QueryIsValidIdRef(elementOriginMap, currentFileUri))
         {
-            await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}}.Id.ToString());
         }
+    {{else}}
+        {{#if (Property.QueryHasDefaultValueWithDifferentValueThanDefault property)}}
+            {{#unless (Property.QueryIsBool property)}}
+            if(poco.{{Property.WritePropertyName property}} != {{Property.WriteDefaultValue property}})
+            {
+            {{/unless}}
+        {{/if}}
+        {{#if (Property.QueryIsBool property)}}
+            {{#if (Property.QueryIsImpliedIncluded property)}}
+            if(writerOptions.IncludeImplied || poco.IsImpliedIncluded)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
+            }
+            {{else}}
+            {{#if (Property.QueryHasDefaultValueWithDifferentValueThanDefault property)}}
+                if(!poco.{{Property.WritePropertyName property}})
+                {
+                await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, "false");
+                }
+            {{else}}
+                if(poco.{{Property.WritePropertyName property}})
+                {
+                await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, "true");
+                }
+            {{/if}}
+            {{/if}}
+        {{else if (Property.QueryIsEnum property)}}
+            {{#if (Property.QueryIsNullable property)}}
+                if(poco.{{Property.WritePropertyName property}}.HasValue)
+                {
+                await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}}.Value.ToString().ToLower());
+                }
+            {{else}}
+                await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}}.ToString().ToLower());
+            {{/if}}
+        {{else if (Property.QueryIsNumeric property)}}
+            await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}}.ToString(CultureInfo.InvariantCulture));
         {{else}}
-        if(poco.{{Property.WritePropertyName property}})
-        {
-            await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, "true");
-        }
+            if(!string.IsNullOrWhiteSpace(poco.{{Property.WritePropertyName property}}))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}});
+            }
+        {{/if}}
+        {{#if (Property.QueryHasDefaultValueWithDifferentValueThanDefault property)}}
+            {{#unless (Property.QueryIsBool property)}}
+                }
+            {{/unless}}
         {{/if}}
-    {{else if (Property.QueryIsEnum property)}}
-        await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}}.ToString());
-    {{else if (Property.QueryIsNumeric property)}}
-        await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}}.ToString(CultureInfo.InvariantCulture));
-    {{else}}
-        if(!string.IsNullOrWhiteSpace(poco.{{Property.WritePropertyName property}}))
-        {
-            await xmlWriter.WriteAttributeStringAsync(null, "{{String.LowerCaseFirstLetter property.Name}}", null, poco.{{Property.WritePropertyName property}});
-        }
     {{/if}}
 {{/if}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs
index b51f930f3..90355107c 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-attribute-template.hbs
@@ -1,36 +1,70 @@
 {{#if (Property.QueryIsEnumerable property)}}
-    {{#if (Property.QueryIsBool property)}}
-        if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
-        {
-            xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", string.Join(" ", poco.{{Property.WritePropertyName property}}));
-        }
-    {{else}}
-        if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
-        {
-            xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", string.Join(" ", poco.{{Property.WritePropertyName property}}));
-        }
-    {{/if}}
-{{else}}
-    {{#if (Property.QueryIsBool property)}}
-        {{#if (Property.QueryIsImpliedIncluded property)}}
-        if(includesImplied || poco.IsImpliedIncluded)
-        {
-            xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
-        }
+    {{#unless (Property.QueryIsReferenceProperty property)}}
+        {{#if (Property.QueryIsBool property)}}
+            if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", string.Join(" ", poco.{{Property.WritePropertyName property}}));
+            }
         {{else}}
-        if(poco.{{Property.WritePropertyName property}})
+            if(poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.Count > 0)
+            {
+                xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", string.Join(" ", poco.{{Property.WritePropertyName property}}));
+            }
+        {{/if}}
+    {{/unless}}        
+{{else}}
+    {{#if (Property.QueryIsReferenceProperty property)}}
+        if(writerOptions.WriteIdRefAsAttribute && poco.{{Property.WritePropertyName property}} != null && poco.{{Property.WritePropertyName property}}.QueryIsValidIdRef(elementOriginMap, currentFileUri))
         {
-            xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", "true");
+            xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}}.Id.ToString());
         }
-        {{/if}}
-    {{else if (Property.QueryIsEnum property)}}
-        xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}}.ToString());
-    {{else if (Property.QueryIsNumeric property)}}
-        xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}}.ToString(CultureInfo.InvariantCulture));
     {{else}}
-        if(!string.IsNullOrWhiteSpace(poco.{{Property.WritePropertyName property}}))
-        {
+        {{#if (Property.QueryHasDefaultValueWithDifferentValueThanDefault property)}}
+            {{#unless (Property.QueryIsBool property)}}
+                if(poco.{{Property.WritePropertyName property}} != {{Property.WriteDefaultValue property}})
+                {
+            {{/unless}}
+        {{/if}}
+        {{#if (Property.QueryIsBool property)}}
+            {{#if (Property.QueryIsImpliedIncluded property)}}
+                if(writerOptions.IncludeImplied || poco.IsImpliedIncluded)
+                {
+                xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
+                }
+            {{else}}
+                {{#if (Property.QueryHasDefaultValueWithDifferentValueThanDefault property)}}
+                    if(!poco.{{Property.WritePropertyName property}})
+                    {
+                    xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", "false");
+                    }
+                {{else}}
+                    if(poco.{{Property.WritePropertyName property}})
+                    {
+                    xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", "true");
+                    }
+                {{/if}}
+            {{/if}}
+        {{else if (Property.QueryIsEnum property)}}
+            {{#if (Property.QueryIsNullable property)}}
+                if(poco.{{Property.WritePropertyName property}}.HasValue)
+                {
+                    xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}}.Value.ToString().ToLower());
+                }
+            {{else}}
+            xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}}.ToString().ToLower());
+            {{/if}}
+        {{else if (Property.QueryIsNumeric property)}}
+            xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}}.ToString(CultureInfo.InvariantCulture));
+        {{else}}
+            if(!string.IsNullOrWhiteSpace(poco.{{Property.WritePropertyName property}}))
+            {
             xmlWriter.WriteAttributeString("{{String.LowerCaseFirstLetter property.Name}}", poco.{{Property.WritePropertyName property}});
-        }
+            }
+        {{/if}}
+        {{#if (Property.QueryHasDefaultValueWithDifferentValueThanDefault property)}}
+            {{#unless (Property.QueryIsBool property)}}
+                }
+            {{/unless}}
+        {{/if}}
     {{/if}}
 {{/if}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-async-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-async-template.hbs
index 9a0efebfd..be4920bb9 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-async-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-async-template.hbs
@@ -4,9 +4,9 @@
         foreach(var item in poco.{{Property.WritePropertyName property}})
         {
             {{#if property.IsComposite}}
-                await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "{{String.LowerCaseFirstLetter property.Name}}", writerOptions, elementOriginMap, currentFileUri{{#if property.Type.IsAbstract}}, true{{/if}});
             {{else}}
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri{{#if property.Type.IsAbstract}}, true{{/if}});
             {{/if}}
         }
     }
@@ -14,9 +14,12 @@
     if(poco.{{Property.WritePropertyName property}} != null)
     {
         {{#if property.IsComposite}}
-            await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+            await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", writerOptions, elementOriginMap, currentFileUri{{#if property.Type.IsAbstract}}, true{{/if}});
         {{else}}
-            await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
+            if(!writerOptions.WriteIdRefAsAttribute || !poco.{{Property.WritePropertyName property}}.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri{{#if property.Type.IsAbstract}}, true{{/if}});
+            }
         {{/if}}
     }
 {{/if}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs
index b086fdcdb..e7e8da642 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-writer-partial-for-element-template.hbs
@@ -4,9 +4,9 @@
         foreach(var item in poco.{{Property.WritePropertyName property}})
         {
             {{#if property.IsComposite}}
-                this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", writerOptions, elementOriginMap, currentFileUri{{#if property.Type.IsAbstract}}, true{{/if}});
             {{else}}
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri{{#if property.Type.IsAbstract}}, true{{/if}});
             {{/if}}
         }
     }
@@ -14,9 +14,12 @@
     if(poco.{{Property.WritePropertyName property}} != null)
     {
         {{#if property.IsComposite}}
-            this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+            this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", writerOptions, elementOriginMap, currentFileUri{{#if property.Type.IsAbstract}}, true{{/if}});
         {{else}}
-            this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri);
+            if(!writerOptions.WriteIdRefAsAttribute || !poco.{{Property.WritePropertyName property}}.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.{{Property.WritePropertyName property}}, "{{String.LowerCaseFirstLetter property.Name}}", elementOriginMap, currentFileUri{{#if property.Type.IsAbstract}}, true{{/if}});
+            }
         {{/if}}
     }
 {{/if}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
index 09ae3f4d1..9a54ee49c 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
@@ -48,12 +48,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <summary>
         /// A dictionary that contains actions that write <see cref="IData"/> based on a key that represents the POCO type name
         /// </summary>
-        private readonly Dictionary<string, Action<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri>> writerCache;
+        private readonly Dictionary<string, Action<XmlWriter, IData, string, XmiWriterOptions, IXmiElementOriginMap, Uri>> writerCache;
 
         /// <summary>
         /// A dictionary that contains functions that asynchronously write <see cref="IData"/> based on a key that represents the POCO type name
         /// </summary>
-        private readonly Dictionary<string, Func<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri, Task>> writerAsyncCache;
+        private readonly Dictionary<string, Func<XmlWriter, IData, string, XmiWriterOptions, IXmiElementOriginMap, Uri, Task>> writerAsyncCache;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="XmiDataWriterFacade"/>
@@ -63,24 +63,24 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         {
             this.loggerFactory = loggerFactory;
 
-            this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri>>
+            this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, XmiWriterOptions, IXmiElementOriginMap, Uri>>
             {
             {{ #each this as | class | }}
-                ["{{ class.Name }}"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["{{ class.Name }}"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new {{ class.Name }}Writer(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, writerOptions, originMap, uri);
                 },
             {{/each}}
             };
 
-            this.writerAsyncCache = new Dictionary<string, Func<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri, Task>>
+            this.writerAsyncCache = new Dictionary<string, Func<XmlWriter, IData, string, XmiWriterOptions, IXmiElementOriginMap, Uri, Task>>
             {
             {{ #each this as | class | }}
-                ["{{ class.Name }}"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["{{ class.Name }}"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new {{ class.Name }}Writer(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, writerOptions, originMap, uri);
                 },
             {{/each}}
             };
@@ -92,16 +92,16 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="data">The <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public void Write(XmlWriter xmlWriter, IData data, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             var typeName = data.GetType().Name;
 
             if (this.writerCache.TryGetValue(typeName, out var writer))
             {
-                writer(xmlWriter, data, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                writer(xmlWriter, data, elementName, writerOptions, elementOriginMap, currentFileUri);
             }
             else
             {
@@ -115,12 +115,13 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="childData">The child <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false)
         {
-            if (!includesImplied && childData is IRelationship rel && rel.IsImplied)
+            if (!writerOptions.IncludeImplied && childData is IRelationship rel && rel.IsImplied)
             {
                 return;
             }
@@ -131,12 +132,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
 
                 if (childSourceFile != null && childSourceFile != currentFileUri)
                 {
-                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri, shouldSpecifyType);
                     return;
                 }
             }
 
-            this.Write(xmlWriter, childData, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+            this.Write(xmlWriter, childData, elementName, writerOptions, elementOriginMap, currentFileUri);
         }
 
         /// <summary>
@@ -147,7 +148,8 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="elementName">The XML element name to use</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        public void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false)
         {
             if (elementOriginMap != null && currentFileUri != null)
             {
@@ -155,7 +157,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
 
                 if (childSourceFile != null && childSourceFile != currentFileUri)
                 {
-                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri, shouldSpecifyType);
                     return;
                 }
             }
@@ -171,16 +173,16 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="data">The <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public async Task WriteAsync(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public async Task WriteAsync(XmlWriter xmlWriter, IData data, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             var typeName = data.GetType().Name;
 
             if (this.writerAsyncCache.TryGetValue(typeName, out var writer))
             {
-                await writer(xmlWriter, data, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                await writer(xmlWriter, data, elementName, writerOptions, elementOriginMap, currentFileUri);
             }
             else
             {
@@ -194,12 +196,13 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="childData">The child <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public async Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        public async Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childData, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false)
         {
-            if (!includesImplied && childData is IRelationship rel && rel.IsImplied)
+            if (!writerOptions.IncludeImplied && childData is IRelationship rel && rel.IsImplied)
             {
                 return;
             }
@@ -210,12 +213,12 @@ namespace SysML2.NET.Serializer.Xmi.Writers
 
                 if (childSourceFile != null && childSourceFile != currentFileUri)
                 {
-                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri, shouldSpecifyType);
                     return;
                 }
             }
 
-            await this.WriteAsync(xmlWriter, childData, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+            await this.WriteAsync(xmlWriter, childData, elementName, writerOptions, elementOriginMap, currentFileUri);
         }
 
         /// <summary>
@@ -226,7 +229,8 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="elementName">The XML element name to use</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public async Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        public async Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false)
         {
             if (elementOriginMap != null && currentFileUri != null)
             {
@@ -234,7 +238,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
 
                 if (childSourceFile != null && childSourceFile != currentFileUri)
                 {
-                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri, shouldSpecifyType);
                     return;
                 }
             }
@@ -247,12 +251,18 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <summary>
         /// Writes an href element for cross-file references
         /// </summary>
-        private static void WriteHrefElement(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile)
+        private static void WriteHrefElement(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile, bool shouldSpecifyType)
         {
             var relativePath = currentFile.MakeRelativeUri(targetFile);
             var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{childData.Id}";
 
             xmlWriter.WriteStartElement(elementName);
+            
+            if(shouldSpecifyType)
+            {
+                xmlWriter.WriteAttributeString("xsi", "type", null, $"sysml:{childData.GetType().Name}");
+            }
+            
             xmlWriter.WriteAttributeString("href", href);
             xmlWriter.WriteEndElement();
         }
@@ -260,12 +270,18 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <summary>
         /// Asynchronously writes an href element for cross-file references
         /// </summary>
-        private static async Task WriteHrefElementAsync(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile)
+        private static async Task WriteHrefElementAsync(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile, bool shouldSpecifyType)
         {
             var relativePath = currentFile.MakeRelativeUri(targetFile);
             var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{childData.Id}";
 
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
+            
+            if(shouldSpecifyType)
+            {
+                await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, $"sysml:{childData.GetType().Name}");
+            }
+            
             await xmlWriter.WriteAttributeStringAsync(null, "href", null, href);
             await xmlWriter.WriteEndElementAsync();
         }
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
index b2d79bb55..0bc18d3ac 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-template.hbs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     {{ #Class.WriteNameSpaces this POCO}}
     using SysML2.NET.Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace this }};
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="{{this.Name}}Writer" /> is to write an instance of <see cref="I{{this.Name}}" />
@@ -68,17 +69,10 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="I{{this.Name}}" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, I{{this.Name}} poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, I{{this.Name}} poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:{{this.Name}}");
@@ -88,17 +82,19 @@ namespace SysML2.NET.Serializer.Xmi.Writers
             {{#with this as |class| }}
                 {{ #each (Class.QueryAllPropertiesSorted this) as | property | }}
                     {{#unless this.IsTransient}}
-                        {{#unless (Property.QueryIsReferenceProperty this)}}
+                        {{#unless (Property.QueryIsEnumerableAndReferenceProperty this)}}
                             {{#unless (Property.IsPropertyRedefinedInClass this class)}}
-                                {{#if this.IsDerived}}
-                                    if(includeDerivedProperties)
-                                    {
+                                {{#unless property.Opposite.IsComposite}}
+                                    {{#if this.IsDerived}}
+                                        if(writerOptions.IncludeDerivedProperties)
+                                        {
+                                            {{> core-xmi-writer-partial-for-attribute-template this}}
+                                        }
+                                    {{else}}
                                         {{> core-xmi-writer-partial-for-attribute-template this}}
-                                    }
-                                {{else}}
-                                    {{> core-xmi-writer-partial-for-attribute-template this}}
-                                {{/if}}
-
+                                    {{/if}}
+        
+                                {{/unless}}
                             {{/unless}}
                         {{/unless}}
                     {{/unless}}
@@ -111,8 +107,9 @@ namespace SysML2.NET.Serializer.Xmi.Writers
                     {{#unless this.IsTransient}}
                         {{#if (Property.QueryIsReferenceProperty this)}}
                             {{#unless (Property.IsPropertyRedefinedInClass this class)}}
-                                {{#if this.IsDerived}}
-                                    if(includeDerivedProperties)
+                                {{#unless property.Opposite.IsComposite}}
+                                    {{#if this.IsDerived}}
+                                    if(writerOptions.IncludeDerivedProperties)
                                     {
                                         {{> core-xmi-writer-partial-for-element-template this}}
                                     }
@@ -121,6 +118,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
                                 {{/if}}
                                 
                             {{/unless}}
+                            {{/unless}}
                         {{/if}}
                     {{/unless}}
                 {{/each}}
@@ -135,18 +133,11 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="I{{this.Name}}" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, I{{this.Name}} poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, I{{this.Name}} poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:{{this.Name}}");
@@ -156,17 +147,19 @@ namespace SysML2.NET.Serializer.Xmi.Writers
             {{#with this as |class| }}
                 {{ #each (Class.QueryAllPropertiesSorted this) as | property | }}
                     {{#unless this.IsTransient}}
-                        {{#unless (Property.QueryIsReferenceProperty this)}}
+                        {{#unless (Property.QueryIsEnumerableAndReferenceProperty this)}}
                             {{#unless (Property.IsPropertyRedefinedInClass this class)}}
-                                {{#if this.IsDerived}}
-                                    if(includeDerivedProperties)
+                                {{#unless property.Opposite.IsComposite}}
+                                    {{#if this.IsDerived}}
+                                    if(writerOptions.IncludeDerivedProperties)
                                     {
                                         {{> core-xmi-writer-partial-for-attribute-async-template this}}
                                     }
                                 {{else}}
                                     {{> core-xmi-writer-partial-for-attribute-async-template this}}
                                 {{/if}}
-
+    
+                                {{/unless}}
                             {{/unless}}
                         {{/unless}}
                     {{/unless}}
@@ -178,9 +171,10 @@ namespace SysML2.NET.Serializer.Xmi.Writers
                 {{ #each (Class.QueryAllPropertiesSorted this) as | property | }}
                     {{#unless this.IsTransient}}
                         {{#if (Property.QueryIsReferenceProperty this)}}
+                            {{#unless property.Opposite.IsComposite}}
                             {{#unless (Property.IsPropertyRedefinedInClass this class)}}
                                 {{#if this.IsDerived}}
-                                    if(includeDerivedProperties)
+                                    if(writerOptions.IncludeDerivedProperties)
                                     {
                                         {{> core-xmi-writer-partial-for-element-async-template this}}
                                     }
@@ -189,6 +183,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
                                 {{/if}}
 
                             {{/unless}}
+                            {{/unless}}
                         {{/if}}
                     {{/unless}}
                 {{/each}}
diff --git a/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
index 2694e6145..79af6e56c 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
@@ -23,19 +23,23 @@ namespace SysML2.NET.Serializer.Xmi.Tests
     using System;
     using System.IO;
     using System.Linq;
-
-    using Core.POCO.Root.Namespaces;
+    using System.Xml;
 
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.Logging;
 
+    using Org.XmlUnit.Builder;
+    using Org.XmlUnit.Diff;
+
     using SysML2.NET.Serializer.Xmi.Extensions;
     using SysML2.NET.Serializer.Xmi.Readers;
+    using SysML2.NET.Serializer.Xmi.Writers;
 
     [TestFixture]
     public class RoundTripTestFixture
     {
         private ILoggerFactory loggerFactory;
+        private XmiWriterOptions writerOptions = new();
 
         [SetUp]
         public void Setup()
@@ -51,6 +55,7 @@ public void Setup()
         public void Verify_that_deserialization_with_origin_map_tracks_elements()
         {
             var xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
+            
             var deSerializer = new DeSerializer(
                 new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
                 new XmiDataReaderFacade(),
@@ -85,6 +90,7 @@ public void Verify_that_serialized_output_is_well_formed_xml_with_correct_root()
         {
             // Step 1: Deserialize original
             var xmiDataCache1 = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
+            
             var deSerializer1 = new DeSerializer(
                 new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
                 new XmiDataReaderFacade(),
@@ -100,7 +106,7 @@ public void Verify_that_serialized_output_is_well_formed_xml_with_correct_root()
             var serializer = new Serializer(this.loggerFactory);
             var memoryStream = new MemoryStream();
 
-            serializer.Serialize(originalNamespace, false, false, memoryStream);
+            serializer.Serialize(originalNamespace, this.writerOptions, memoryStream);
 
             Assert.That(memoryStream.Length, Is.GreaterThan(0));
 
@@ -124,6 +130,7 @@ public void Verify_that_serialized_output_is_well_formed_xml_with_correct_root()
         public void Verify_that_origin_map_captures_multi_file_references()
         {
             var xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
+            
             var deSerializer = new DeSerializer(
                 new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
                 new XmiDataReaderFacade(),
@@ -150,5 +157,112 @@ public void Verify_that_origin_map_captures_multi_file_references()
                 Assert.That(rootNsId, Is.Not.EqualTo(Guid.Empty), $"Root namespace not registered for {sourceFile}");
             }
         }
+
+        [Test]
+        public void VerifySerializedXmlCorrespondToOriginalFile()
+        {
+            var xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
+            
+            var deSerializer = new DeSerializer(
+                new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
+                new XmiDataReaderFacade(),
+                xmiDataCache,
+                this.loggerFactory);
+
+            var originMap = new XmiElementOriginMap();
+
+            // Quantities.sysmlx references other files like ScalarValues.kermlx, ISQBase.sysmlx, etc.
+            var filePath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "Domain Libraries", "Quantities and Units", "Quantities.sysmlx");
+            var fileUri = new Uri(filePath);
+
+            var quantityNamespace = deSerializer.DeSerialize(fileUri, originMap);
+            
+            var serializer = new Serializer(this.loggerFactory);
+            var outputFile = Path.Combine(TestContext.CurrentContext.TestDirectory, "SerializedQuantities.sysmlx");
+            
+            var fileStream = new FileStream(outputFile, FileMode.Create);
+            
+            serializer.Serialize(quantityNamespace, this.writerOptions, fileStream, originMap, new Uri(filePath));
+            fileStream.Close();
+
+            var content = File.ReadAllText(outputFile);
+            
+            var xmlDiff = DiffBuilder.Compare(Input.FromFile(filePath))
+                .WithTest(Input.FromString(content.Replace("http://www.omg.org/spec/XMI/20131001", "http://www.omg.org/XMI")))
+                .IgnoreWhitespace() 
+                .IgnoreComments() 
+                .WithAttributeFilter(attr => attr.LocalName != "version")
+                .WithDifferenceEvaluator((comparison, outcome) =>
+                {
+                    switch (comparison.Type)
+                    {
+                        case ComparisonType.XML_ENCODING:
+                        case ComparisonType.XML_VERSION:
+                            return ComparisonResult.EQUAL;
+                        case ComparisonType.ATTR_VALUE:
+                        {
+                            var control = comparison.ControlDetails.Value?.ToString()?.Replace("%20", " ");
+                            var test = comparison.TestDetails.Value?.ToString()?.Replace("%20", " ");
+
+                            if (control == test)
+                            {
+                                return ComparisonResult.EQUAL;
+                            }
+
+                            break;
+                        }
+                        
+                        case ComparisonType.ATTR_NAME_LOOKUP:
+                        {
+                            if (outcome != ComparisonResult.EQUAL && comparison.ControlDetails.Target is XmlElement controlElement)
+                            {
+                                var testElement = (XmlElement)comparison.TestDetails.Target;
+
+                                if (controlElement.HasAttribute("isComposite") && !testElement.HasAttribute("isComposite"))
+                                {
+                                    return controlElement.GetAttribute("isComposite") == "false" ? ComparisonResult.EQUAL : ComparisonResult.DIFFERENT;
+                                }
+
+                                if (controlElement.HasAttribute("declaredName") && !testElement.HasAttribute("declaredName"))
+                                {
+                                    return controlElement.GetAttribute("declaredName") == "" ? ComparisonResult.EQUAL : ComparisonResult.DIFFERENT;
+                                }
+                            }
+
+                            break;
+                        }
+
+                        case ComparisonType.ELEMENT_NUM_ATTRIBUTES:
+                        {
+                            var controlCount = Convert.ToInt32(comparison.ControlDetails.Value);
+                            var testCount = Convert.ToInt32(comparison.TestDetails.Value);
+
+                            if (Math.Abs(controlCount - testCount) == 1)
+                            {
+                                var controlElement =(XmlElement)comparison.ControlDetails.Target;
+                                var testElement = (XmlElement)comparison.TestDetails.Target;
+
+                                if (controlElement.HasAttribute("isComposite") && !testElement.HasAttribute("isComposite"))
+                                {
+                                    return controlElement.GetAttribute("isComposite") == "false" ? ComparisonResult.EQUAL : ComparisonResult.DIFFERENT;
+                                }
+                                
+                                if (controlElement.HasAttribute("declaredName") && !testElement.HasAttribute("declaredName"))
+                                {
+                                    return controlElement.GetAttribute("declaredName") == "" ? ComparisonResult.EQUAL : ComparisonResult.DIFFERENT;
+                                }
+                            }
+
+                            break;
+                        }
+                    }
+                    
+                    return outcome;
+                })
+                .CheckForIdentical()
+                .Build();
+            
+            Assert.That(xmlDiff.HasDifferences, Is.False);
+        }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
index 5babb1b0d..31f81f460 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
@@ -34,6 +34,7 @@ namespace SysML2.NET.Serializer.Xmi.Tests
 
     using SysML2.NET.Serializer.Xmi.Extensions;
     using SysML2.NET.Serializer.Xmi.Readers;
+    using SysML2.NET.Serializer.Xmi.Writers;
 
     [TestFixture]
     public class SerializerTestFixture
@@ -43,7 +44,8 @@ public class SerializerTestFixture
         private XmiDataCache xmiDataCache;
 
         private INamespace anonymouseNameSpace;
-
+        private XmiWriterOptions writerOptions = new();
+        
         [SetUp]
         public void Setup()
         {
@@ -65,7 +67,7 @@ public void Verify_that_the_name_space_can_be_serialized_to_xmi()
         {
             var targetStream = new MemoryStream();
 
-            Assert.That(() => this.serializer.Serialize(this.anonymouseNameSpace, false, false, targetStream), Throws.Nothing);
+            Assert.That(() => this.serializer.Serialize(this.anonymouseNameSpace, this.writerOptions, targetStream), Throws.Nothing);
 
             Assert.That(targetStream.Length, Is.GreaterThan(0));
         }
@@ -75,7 +77,7 @@ public void Verify_that_serialized_xmi_contains_expected_structure()
         {
             var targetStream = new MemoryStream();
 
-            this.serializer.Serialize(this.anonymouseNameSpace, false, false, targetStream);
+            this.serializer.Serialize(this.anonymouseNameSpace, this.writerOptions, targetStream);
 
             targetStream.Seek(0, SeekOrigin.Begin);
             var reader = new StreamReader(targetStream);
@@ -92,7 +94,7 @@ public async Task Verify_that_the_name_space_can_be_serialized_to_xmi_async()
         {
             var targetStream = new MemoryStream();
 
-            await this.serializer.SerializeAsync(this.anonymouseNameSpace, false, false, targetStream, CancellationToken.None);
+            await this.serializer.SerializeAsync(this.anonymouseNameSpace, this.writerOptions, targetStream, CancellationToken.None);
 
             Assert.That(targetStream.Length, Is.GreaterThan(0));
         }
@@ -107,7 +109,7 @@ public void Verify_that_includesImplied_false_excludes_implied_relationships()
             var impliedId = impliedRelationship.Id.ToString();
 
             var targetStream = new MemoryStream();
-            this.serializer.Serialize(this.anonymouseNameSpace, false, false, targetStream);
+            this.serializer.Serialize(this.anonymouseNameSpace, this.writerOptions, targetStream);
 
             targetStream.Seek(0, SeekOrigin.Begin);
             var content = new StreamReader(targetStream).ReadToEnd();
@@ -126,7 +128,7 @@ public void Verify_that_includesImplied_true_includes_implied_and_sets_isImplied
             impliedRelationship.IsImpliedIncluded = false;
 
             var targetStream = new MemoryStream();
-            this.serializer.Serialize(this.anonymouseNameSpace, false, true, targetStream);
+            this.serializer.Serialize(this.anonymouseNameSpace, new XmiWriterOptions(){IncludeImplied = true}, targetStream);
 
             targetStream.Seek(0, SeekOrigin.Begin);
             var content = new StreamReader(targetStream).ReadToEnd();
@@ -140,7 +142,7 @@ public void Verify_that_includesImplied_false_uses_per_element_isImpliedIncluded
             this.anonymouseNameSpace.IsImpliedIncluded = true;
 
             var targetStream = new MemoryStream();
-            this.serializer.Serialize(this.anonymouseNameSpace, false, false, targetStream);
+            this.serializer.Serialize(this.anonymouseNameSpace, this.writerOptions, targetStream);
 
             targetStream.Seek(0, SeekOrigin.Begin);
             var content = new StreamReader(targetStream).ReadToEnd();
diff --git a/SysML2.NET.Serializer.Xmi.Tests/SysML2.NET.Serializer.Xmi.Tests.csproj b/SysML2.NET.Serializer.Xmi.Tests/SysML2.NET.Serializer.Xmi.Tests.csproj
index 0cbcab687..0fcda5077 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/SysML2.NET.Serializer.Xmi.Tests.csproj
+++ b/SysML2.NET.Serializer.Xmi.Tests/SysML2.NET.Serializer.Xmi.Tests.csproj
@@ -32,6 +32,7 @@
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
+        <PackageReference Include="XMLUnit.Core" Version="2.11.1" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/SysML2.NET.Serializer.Xmi/Extensions/DataExtension.cs b/SysML2.NET.Serializer.Xmi/Extensions/DataExtension.cs
new file mode 100644
index 000000000..2d54a604e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Extensions/DataExtension.cs
@@ -0,0 +1,55 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="DataExtension.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2026 Starion Group S.A.
+// 
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+// 
+//        http://www.apache.org/licenses/LICENSE-2.0
+// 
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// 
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Extensions
+{
+    using System;
+
+    using SysML2.NET.Common;
+
+    /// <summary>
+    /// Extension class for the <see cref="IData"/> interface
+    /// </summary>
+    public static class DataExtension
+    {
+        /// <summary>
+        /// Verify that the current <see cref="IData"/> can be target via an Id reference or not
+        /// </summary>
+        /// <param name="data">The <see cref="IData"/> that needs to be verified </param>
+        /// <param name="elementOriginMap">The provided <see cref="IXmiElementOriginMap"/> that should be used to verify the registration of the <see cref="IData"/></param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> that locates an XMI file</param>
+        /// <returns><c>true</c> if the <see cref="IData"/> can be referenced via identifier, <c>false</c> otherwise</returns>
+        public static bool QueryIsValidIdRef(this IData data, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        {
+            if (data == null)
+            {
+                throw new NullReferenceException(nameof(data));
+            }
+
+            if (elementOriginMap == null || currentFileUri == null)
+            {
+                return true;
+            }
+
+            var sourceFile = elementOriginMap.GetSourceFile(data.Id);
+            return sourceFile == null || sourceFile == currentFileUri;
+        }
+    }
+}
diff --git a/SysML2.NET.Serializer.Xmi/ISerializer.cs b/SysML2.NET.Serializer.Xmi/ISerializer.cs
index 7ead9ea82..bf8cb9861 100644
--- a/SysML2.NET.Serializer.Xmi/ISerializer.cs
+++ b/SysML2.NET.Serializer.Xmi/ISerializer.cs
@@ -28,6 +28,7 @@ namespace SysML2.NET.Serializer.Xmi
 
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Serializer.Xmi.Writers;
 
     /// <summary>
     /// The purpose of the <see cref="ISerializer"/> is to write an <see cref="INamespace"/>
@@ -41,20 +42,11 @@ public interface ISerializer
         /// <param name="namespace">
         /// The <see cref="INamespace"/> that shall be serialized
         /// </param>
-        /// <param name="includeDerivedProperties">
-        /// Asserts that derived properties should also be part of the serialization
-        /// </param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
-        void Serialize(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream);
+        void Serialize(INamespace @namespace, XmiWriterOptions writerOptions, Stream stream);
 
         /// <summary>
         /// Serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>,
@@ -63,13 +55,7 @@ public interface ISerializer
         /// <param name="namespace">
         /// The <see cref="INamespace"/> that shall be serialized
         /// </param>
-        /// <param name="includeDerivedProperties">
-        /// Asserts that derived properties should also be part of the serialization
-        /// </param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag. <c>true</c>: serialize all implied relationships with isImpliedIncluded=true.
-        /// <c>false</c>: exclude all implied relationships with isImpliedIncluded=false. <c>null</c>: per-element control.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
@@ -79,7 +65,7 @@ public interface ISerializer
         /// <param name="currentFileUri">
         /// The optional <see cref="Uri"/> of the current output file for relative href computation
         /// </param>
-        void Serialize(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+        void Serialize(INamespace @namespace, XmiWriterOptions writerOptions, Stream stream, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
 
         /// <summary>
         /// Asynchronously serialize an <see cref="INamespace"/> as XMI to a target <see cref="Stream"/>
@@ -90,17 +76,11 @@ public interface ISerializer
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
-        /// <param name="includeDerivedProperties">
-        /// Asserts that derived properties should also be part of the serialization
-        /// </param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag. <c>true</c>: serialize all implied relationships with isImpliedIncluded=true.
-        /// <c>false</c>: exclude all implied relationships with isImpliedIncluded=false. <c>null</c>: per-element control.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="cancellationToken">
         /// The <see cref="CancellationToken"/> used to cancel the operation
         /// </param>
-        Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream, CancellationToken cancellationToken);
+        Task SerializeAsync(INamespace @namespace, XmiWriterOptions writerOptions, Stream stream, CancellationToken cancellationToken);
 
         /// <summary>
         /// Serialize an <see cref="INamespace"/> to multiple XMI files based on the element origin map
@@ -108,13 +88,7 @@ public interface ISerializer
         /// <param name="rootNamespace">The root <see cref="INamespace"/> containing all elements</param>
         /// <param name="elementOriginMap">The <see cref="IXmiElementOriginMap"/> tracking element-to-file associations</param>
         /// <param name="outputDirectory">The target directory for output files</param>
-        /// <param name="includeDerivedProperties">
-        /// Asserts that derived properties should also be part of the serialization
-        /// </param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag. <c>true</c>: serialize all implied relationships with isImpliedIncluded=true.
-        /// <c>false</c>: exclude all implied relationships with isImpliedIncluded=false. <c>null</c>: per-element control.
-        /// </param>
-        void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOriginMap, DirectoryInfo outputDirectory, bool includeDerivedProperties, bool includesImplied);
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
+        void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOriginMap, DirectoryInfo outputDirectory, XmiWriterOptions writerOptions);
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Serializer.cs b/SysML2.NET.Serializer.Xmi/Serializer.cs
index 1bb92ff55..c797628a0 100644
--- a/SysML2.NET.Serializer.Xmi/Serializer.cs
+++ b/SysML2.NET.Serializer.Xmi/Serializer.cs
@@ -41,16 +41,34 @@ namespace SysML2.NET.Serializer.Xmi
     /// </summary>
     public class Serializer : ISerializer
     {
+        /// <summary>
+        /// Gets the URI of the XMI namespace location
+        /// </summary>
         private const string XmiNamespace = "http://www.omg.org/spec/XMI/20131001";
         
+        /// <summary>
+        /// Gets the URI of the XSI namespace location
+        /// </summary>
         private const string XsiNamespace = "http://www.w3.org/2001/XMLSchema-instance";
         
-        private const string SysmlNamespace = "https://www.omg.org/spec/SysML/20240201";
+        /// <summary>
+        /// Gets the URI of the SysML namespace location
+        /// </summary>
+        private const string SysmlNamespace = "https://www.omg.org/spec/SysML/20250201";
 
+        /// <summary>
+        /// Gets the <see cref="ILogger{TCategoryName}"/> instance to perform logging statement
+        /// </summary>
         private readonly ILogger<Serializer> logger;
         
+        /// <summary>
+        /// Gets the <see cref="ILoggerFactory"/> instance used to set up logging
+        /// </summary>
         private readonly ILoggerFactory loggerFactory;
         
+        /// <summary>
+        /// Gets the <see cref="IXmiDataWriterFacade"/> to dispatch <see cref="IElement"/> writing
+        /// </summary>
         private readonly IXmiDataWriterFacade xmiWriterFacade;
 
         /// <summary>Initializes a new instance of the <see cref="Serializer"></see> class.</summary>
@@ -68,22 +86,13 @@ public Serializer(ILoggerFactory loggerFactory)
         /// <param name="namespace">
         /// The <see cref="INamespace"/> that shall be serialized
         /// </param>
-        /// <param name="includeDerivedProperties">
-        /// Asserts that derived properties should also be part of the serialization
-        /// </param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
-        public void Serialize(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream)
+        public void Serialize(INamespace @namespace, XmiWriterOptions writerOptions, Stream stream)
         {
-            this.Serialize(@namespace, includeDerivedProperties,includesImplied, stream, null, null);
+            this.Serialize(@namespace, writerOptions, stream, null, null);
         }
 
         /// <summary>
@@ -93,16 +102,7 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, bool
         /// <param name="namespace">
         /// The <see cref="INamespace"/> that shall be serialized
         /// </param>
-        /// <param name="includeDerivedProperties">
-        /// Asserts that derived properties should also be part of the serialization
-        /// </param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
@@ -112,7 +112,7 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, bool
         /// <param name="currentFileUri">
         /// The optional <see cref="Uri"/> of the current output file for relative href computation
         /// </param>
-        public void Serialize(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        public void Serialize(INamespace @namespace, XmiWriterOptions writerOptions, Stream stream, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
         {
             if (@namespace == null)
             {
@@ -124,6 +124,8 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, bool
                 throw new ArgumentNullException(nameof(stream));
             }
 
+            writerOptions ??= new XmiWriterOptions();
+            
             var settings = new XmlWriterSettings
             {
                 Indent = true,
@@ -140,7 +142,7 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, bool
 
             xmlWriter.WriteStartDocument();
 
-            this.WriteNamespaceElement(xmlWriter, @namespace, includeDerivedProperties, elementOriginMap, currentFileUri, includesImplied);
+            this.WriteNamespaceElement(xmlWriter, @namespace, elementOriginMap, currentFileUri, writerOptions);
 
             xmlWriter.WriteEndDocument();
             xmlWriter.Flush();
@@ -157,25 +159,13 @@ public void Serialize(INamespace @namespace, bool includeDerivedProperties, bool
         /// <param name="stream">
         /// The target <see cref="Stream"/>
         /// </param>
-        /// <param name="includeDerivedProperties">
-        /// Asserts that derived properties should also be part of the serialization
-        /// </param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="cancellationToken">
         /// The <see cref="CancellationToken"/> used to cancel the operation
         /// </param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag.
-        /// </param>
-        public Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties, bool includesImplied, Stream stream, CancellationToken cancellationToken)
+        public Task SerializeAsync(INamespace @namespace, XmiWriterOptions writerOptions, Stream stream, CancellationToken cancellationToken)
         {
-            return Task.Run(() => this.Serialize(@namespace, includeDerivedProperties, includesImplied, stream), cancellationToken);
+            return Task.Run(() => this.Serialize(@namespace, writerOptions, stream), cancellationToken);
         }
 
         /// <summary>
@@ -184,17 +174,8 @@ public Task SerializeAsync(INamespace @namespace, bool includeDerivedProperties,
         /// <param name="rootNamespace">The root <see cref="INamespace"/> containing all elements</param>
         /// <param name="elementOriginMap">The <see cref="IXmiElementOriginMap"/> tracking element-to-file associations</param>
         /// <param name="outputDirectory">The target directory for output files</param>
-        /// <param name="includeDerivedProperties">
-        /// Asserts that derived properties should also be part of the serialization
-        /// </param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
-        public void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOriginMap, DirectoryInfo outputDirectory, bool includeDerivedProperties, bool includesImplied)
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
+        public void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOriginMap, DirectoryInfo outputDirectory, XmiWriterOptions writerOptions)
         {
             if (rootNamespace == null)
             {
@@ -211,6 +192,8 @@ public void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOrig
                 throw new ArgumentNullException(nameof(outputDirectory));
             }
 
+            writerOptions ??= new XmiWriterOptions();
+
             if (!outputDirectory.Exists)
             {
                 outputDirectory.Create();
@@ -247,13 +230,21 @@ public void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOrig
                 }
 
                 using var fileStream = new FileStream(outputPath, FileMode.Create, FileAccess.Write);
-                this.Serialize(fileRootNamespace, includeDerivedProperties, includesImplied, fileStream, elementOriginMap, outputUri);
+                this.Serialize(fileRootNamespace, writerOptions, fileStream, elementOriginMap, outputUri);
             }
 
             this.logger.LogInformation("Multi-file XMI serialization completed");
         }
 
-        private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, bool includeDerivedProperties, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool includesImplied)
+        /// <summary>
+        /// Writes the the XML content for the root <see cref="INamespace"/>
+        /// </summary>
+        /// <param name="xmlWriter">The <see cref="XmlWriter"/> instance that provides XMI write features</param>
+        /// <param name="namespace">The root <see cref="INamespace"/> to write</param>
+        /// <param name="elementOriginMap">The <see cref="IXmiElementOriginMap"/> tracking element-to-file associations</param>
+        /// <param name="currentFileUri">The <see cref="Uri"/> that locates the output file</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
+        private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, XmiWriterOptions writerOptions)
         {
             xmlWriter.WriteStartElement("sysml", "Namespace", SysmlNamespace);
             xmlWriter.WriteAttributeString("xmlns", "xmi", null, XmiNamespace);
@@ -281,7 +272,7 @@ private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, b
                 xmlWriter.WriteAttributeString("elementId", @namespace.ElementId);
             }
 
-            if (includesImplied || @namespace.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || @namespace.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -291,7 +282,7 @@ private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, b
             {
                 foreach (var relationship in @namespace.OwnedRelationship)
                 {
-                    if (!includesImplied && relationship is IRelationship { IsImplied: true })
+                    if (!writerOptions.IncludeImplied  && relationship is { IsImplied: true })
                     {
                         continue;
                     }
@@ -314,7 +305,7 @@ private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, b
                             }
                         }
 
-                        this.xmiWriterFacade.Write(xmlWriter, relationshipData, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.xmiWriterFacade.Write(xmlWriter, relationshipData, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -322,6 +313,12 @@ private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, b
             xmlWriter.WriteEndElement();
         }
 
+        /// <summary>
+        /// Finds a <see cref="INamespace" /> based on its <see cref="Guid"/>
+        /// </summary>
+        /// <param name="root">The root <see cref="INamespace"/> used as starting point of the find operation</param>
+        /// <param name="id">The identifier <see cref="Guid"/></param>
+        /// <returns>The <see cref="INamespace"/> if found, <c>null</c> otherwise</returns>
         private static INamespace FindNamespaceById(INamespace root, Guid id)
         {
             if (root.Id == id)
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs
index c540a16fc..a8b9fb1b3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AcceptActionUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AcceptActionUsageWriter" /> is to write an instance of <see cref="IAcceptActionUsage" />
@@ -98,17 +99,10 @@ public AcceptActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAcceptActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AcceptActionUsage");
@@ -120,6 +114,14 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +132,40 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +176,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +199,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -198,7 +227,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -211,9 +240,9 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -221,7 +250,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -229,7 +258,15 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -237,9 +274,92 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadArgument != null && poco.payloadArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("payloadArgument", poco.payloadArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadParameter != null && poco.payloadParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("payloadParameter", poco.payloadParameter.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -247,7 +367,15 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.receiverArgument != null && poco.receiverArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("receiverArgument", poco.receiverArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -257,7 +385,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -268,7 +396,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -279,15 +407,18 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -298,7 +429,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -309,7 +440,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -320,7 +451,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -331,15 +462,18 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -350,7 +484,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -361,15 +495,18 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -380,7 +517,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -391,15 +528,18 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -410,7 +550,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -421,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -432,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -443,18 +583,18 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -465,15 +605,18 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -484,7 +627,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -495,7 +638,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -506,7 +649,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -517,7 +660,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -528,7 +671,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -539,7 +682,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -550,18 +693,18 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -572,7 +715,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -583,7 +726,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -594,7 +737,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -605,7 +748,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -616,7 +759,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -627,7 +770,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -638,7 +781,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -649,7 +792,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -660,7 +803,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -671,7 +814,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -682,7 +825,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -693,7 +836,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -704,7 +847,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -715,7 +858,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -726,7 +869,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -737,7 +880,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -748,7 +891,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -759,7 +902,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -770,7 +913,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -781,7 +924,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -792,67 +935,67 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -863,7 +1006,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -874,99 +1017,99 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -974,127 +1117,121 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1105,31 +1242,40 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadParameter, "payloadParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadParameter, "payloadParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.receiverArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.receiverArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1140,7 +1286,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1151,7 +1297,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1162,7 +1308,7 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1173,13 +1319,13 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1194,18 +1340,11 @@ public override void Write(XmlWriter xmlWriter, IAcceptActionUsage poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAcceptActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AcceptActionUsage");
@@ -1217,6 +1356,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1227,13 +1374,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1244,7 +1418,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1267,7 +1441,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1277,7 +1451,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1295,7 +1469,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1308,9 +1482,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1318,7 +1492,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1326,7 +1500,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1334,9 +1516,92 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadArgument != null && poco.payloadArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "payloadArgument", null, poco.payloadArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadParameter != null && poco.payloadParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "payloadParameter", null, poco.payloadParameter.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1344,7 +1609,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.receiverArgument != null && poco.receiverArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "receiverArgument", null, poco.receiverArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1354,716 +1627,731 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2071,212 +2359,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAcceptActionUsage po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadParameter, "payloadParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.payloadParameter, "payloadParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.receiverArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.receiverArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs
index e8dbc9f01..dc3a2de1c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ActionDefinitionWriter" /> is to write an instance of <see cref="IActionDefinition" />
@@ -94,17 +95,10 @@ public ActionDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IActionDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ActionDefinition");
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,7 +138,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -154,7 +148,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -172,7 +166,15 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -180,7 +182,31 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -188,7 +214,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -198,7 +224,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
@@ -209,7 +235,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -220,7 +246,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -231,7 +257,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -242,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -253,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -264,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -275,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -286,7 +312,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -297,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -308,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -319,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -330,18 +356,18 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -352,15 +378,18 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -371,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -382,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -393,7 +422,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -404,18 +433,18 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -426,7 +455,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -437,7 +466,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -448,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -459,26 +488,26 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -489,40 +518,40 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -533,7 +562,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -544,7 +573,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -555,18 +584,18 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -577,18 +606,18 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -599,18 +628,18 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -621,29 +650,29 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -654,7 +683,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -665,7 +694,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -676,7 +705,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -687,7 +716,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -702,11 +731,11 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -717,7 +746,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -728,18 +757,18 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -750,18 +779,18 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -772,18 +801,18 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -794,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -805,7 +834,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -816,7 +845,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -827,7 +856,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -838,36 +867,29 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -878,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -889,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -900,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -911,7 +933,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -922,7 +944,7 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -933,13 +955,13 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -954,18 +976,11 @@ public override void Write(XmlWriter xmlWriter, IActionDefinition poco, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IActionDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ActionDefinition");
@@ -997,7 +1012,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1005,7 +1020,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poc
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1015,7 +1030,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1033,7 +1048,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1041,7 +1064,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1049,7 +1096,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1059,502 +1106,505 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poc
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "action", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1563,244 +1613,237 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionDefinition poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs
index 3648d3414..bf7cf9a75 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActionUsageWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ActionUsageWriter" /> is to write an instance of <see cref="IActionUsage" />
@@ -97,17 +98,10 @@ public ActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactor
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ActionUsage");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,40 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +175,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +198,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -197,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -210,9 +239,9 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -220,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -228,7 +257,15 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -236,9 +273,76 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -246,7 +350,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -256,7 +360,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -267,7 +371,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -278,15 +382,18 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -297,7 +404,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -308,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -319,7 +426,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -330,15 +437,18 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -349,7 +459,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -360,15 +470,18 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -379,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -390,15 +503,18 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -409,7 +525,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -420,7 +536,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -431,7 +547,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -442,18 +558,18 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -464,15 +580,18 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -483,7 +602,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -494,7 +613,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -505,7 +624,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -516,7 +635,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -527,7 +646,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -538,7 +657,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -549,18 +668,18 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -571,7 +690,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -582,7 +701,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -593,7 +712,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -604,7 +723,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -615,7 +734,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -626,7 +745,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -637,7 +756,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -648,7 +767,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -659,7 +778,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -670,7 +789,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -681,7 +800,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -692,7 +811,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -703,7 +822,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -714,7 +833,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -725,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -736,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -747,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -758,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -769,7 +888,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -780,7 +899,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -791,67 +910,67 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -862,7 +981,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -873,99 +992,99 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -973,127 +1092,121 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1104,7 +1217,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1115,7 +1228,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1126,7 +1239,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1137,7 +1250,7 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1148,13 +1261,13 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1169,18 +1282,11 @@ public override void Write(XmlWriter xmlWriter, IActionUsage poco, string elemen
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ActionUsage");
@@ -1192,6 +1298,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1202,13 +1316,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1219,7 +1360,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1242,7 +1383,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1252,7 +1393,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1270,7 +1411,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1283,9 +1424,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1293,7 +1434,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1301,7 +1442,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1309,9 +1458,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1319,7 +1535,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1329,716 +1545,731 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2046,188 +2277,182 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActionUsage poco, st
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs
index 4372ce7b9..5c84d00f8 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ActorMembershipWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Parts;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ActorMembershipWriter" /> is to write an instance of <see cref="IActorMembership" />
@@ -74,17 +75,10 @@ public ActorMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IActorMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IActorMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IActorMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ActorMembership");
@@ -116,12 +110,12 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -129,7 +123,7 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -137,7 +131,15 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedActorParameter != null && poco.ownedActorParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedActorParameter", poco.ownedActorParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -145,7 +147,7 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -153,7 +155,7 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -161,7 +163,23 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -169,7 +187,7 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -177,11 +195,14 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -192,32 +213,32 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedActorParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedActorParameter, "ownedActorParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedActorParameter, "ownedActorParameter", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -226,7 +247,7 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -234,64 +255,44 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -312,18 +313,11 @@ public override void Write(XmlWriter xmlWriter, IActorMembership poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IActorMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ActorMembership");
@@ -355,12 +349,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -368,7 +362,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -376,7 +370,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedActorParameter != null && poco.ownedActorParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedActorParameter", null, poco.ownedActorParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -384,7 +386,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -392,7 +394,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -400,7 +402,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -408,7 +426,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -416,47 +434,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedActorParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedActorParameter, "ownedActorParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedActorParameter, "ownedActorParameter", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -465,7 +486,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -473,70 +494,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IActorMembership poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs
index 261ba58da..a1676935c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Allocations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AllocationDefinitionWriter" /> is to write an instance of <see cref="IAllocationDefinition" />
@@ -94,17 +95,10 @@ public AllocationDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAllocationDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AllocationDefinition");
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -149,7 +143,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -159,7 +153,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -167,9 +161,9 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (poco.IsSufficient)
+            if (!poco.IsSufficient)
             {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
+                xmlWriter.WriteAttributeString("isSufficient", "false");
             }
 
             if (poco.IsVariation)
@@ -177,7 +171,15 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -185,7 +187,31 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -193,7 +219,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -201,9 +227,17 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceType", poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.allocation != null)
                 {
@@ -214,7 +248,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectionEnd != null)
                 {
@@ -225,7 +259,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -236,7 +270,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -247,7 +281,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -258,7 +292,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -269,7 +303,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -280,7 +314,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -291,7 +325,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -302,7 +336,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -313,7 +347,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -324,7 +358,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -335,7 +369,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -346,18 +380,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -368,15 +402,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -387,7 +424,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -398,7 +435,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -409,7 +446,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -420,18 +457,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -442,7 +479,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -453,7 +490,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -464,7 +501,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -475,26 +512,26 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -505,40 +542,40 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -549,7 +586,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -560,7 +597,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -571,18 +608,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -593,18 +630,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -615,18 +652,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -637,29 +674,29 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -670,7 +707,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -681,7 +718,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -692,7 +729,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -703,7 +740,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -718,7 +755,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -726,11 +763,11 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -741,7 +778,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -752,18 +789,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -774,18 +811,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -796,18 +833,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -818,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -829,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -840,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -851,7 +888,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -862,41 +899,29 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
@@ -907,15 +932,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
@@ -926,7 +954,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -937,7 +965,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -948,7 +976,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -959,7 +987,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -970,13 +998,13 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -991,18 +1019,11 @@ public override void Write(XmlWriter xmlWriter, IAllocationDefinition poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAllocationDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AllocationDefinition");
@@ -1034,7 +1055,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1047,7 +1068,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1057,7 +1078,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1065,9 +1086,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition
                 }
             }
 
-            if (poco.IsSufficient)
+            if (!poco.IsSufficient)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1075,7 +1096,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1083,7 +1112,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1091,7 +1144,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1099,515 +1152,526 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceType", null, poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.allocation != null)
                 {
                     foreach (var item in poco.allocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "allocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "allocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectionEnd != null)
                 {
                     foreach (var item in poco.connectionEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectionEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectionEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1616,7 +1680,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1624,257 +1688,248 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationDefinition
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs
index befe836ee..69fdbff4e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AllocationUsageWriter.cs
@@ -69,6 +69,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Allocations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AllocationUsageWriter" /> is to write an instance of <see cref="IAllocationUsage" />
@@ -99,17 +100,10 @@ public AllocationUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAllocationUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AllocationUsage");
@@ -121,6 +115,14 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -131,13 +133,48 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -148,7 +185,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -176,7 +213,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -186,7 +223,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -204,7 +241,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -217,9 +254,9 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -227,7 +264,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -235,7 +272,15 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -243,9 +288,76 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -253,7 +365,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -261,9 +373,17 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.allocationDefinition != null)
                 {
@@ -274,7 +394,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -285,7 +405,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -296,23 +416,29 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -323,7 +449,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -334,7 +460,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -345,7 +471,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -356,15 +482,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -375,7 +504,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -386,15 +515,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -405,7 +537,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -416,15 +548,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -435,7 +570,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -446,7 +581,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -457,7 +592,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -468,7 +603,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
@@ -479,18 +614,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -501,15 +636,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -520,7 +658,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -531,7 +669,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -542,7 +680,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -553,7 +691,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -564,7 +702,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -575,7 +713,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -586,18 +724,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -608,7 +746,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -619,7 +757,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -630,7 +768,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -641,7 +779,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -652,7 +790,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -663,7 +801,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -674,7 +812,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -685,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -696,7 +834,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -707,7 +845,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -718,7 +856,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -729,7 +867,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -740,7 +878,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -751,7 +889,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -762,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -773,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -784,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -795,7 +933,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -806,7 +944,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -817,7 +955,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -828,67 +966,67 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -899,7 +1037,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -910,99 +1048,99 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1010,7 +1148,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1018,132 +1156,121 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.partDefinition != null)
                 {
@@ -1154,7 +1281,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -1165,15 +1292,18 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -1184,7 +1314,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1195,7 +1325,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1206,7 +1336,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1217,7 +1347,7 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1228,13 +1358,13 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1249,18 +1379,11 @@ public override void Write(XmlWriter xmlWriter, IAllocationUsage poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAllocationUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AllocationUsage");
@@ -1272,6 +1395,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1282,13 +1413,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1299,7 +1465,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1327,7 +1493,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1337,7 +1503,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1355,7 +1521,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1368,9 +1534,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1378,7 +1544,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1386,7 +1552,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1394,9 +1568,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1404,7 +1645,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1412,748 +1653,774 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.allocationDefinition != null)
                 {
                     foreach (var item in poco.allocationDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "allocationDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "allocationDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2161,7 +2428,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -2169,223 +2436,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAllocationUsage poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.partDefinition != null)
                 {
                     foreach (var item in poco.partDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "partDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs
index 0f194cf4d..c59e1e523 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseDefinitionWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.AnalysisCases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AnalysisCaseDefinitionWriter" /> is to write an instance of <see cref="IAnalysisCaseDefinition" />
@@ -95,17 +96,10 @@ public AnalysisCaseDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, IL
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAnalysisCaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AnalysisCaseDefinition");
@@ -137,7 +131,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -145,7 +139,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -155,7 +149,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -163,7 +157,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -181,7 +175,15 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -189,7 +191,39 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("objectiveRequirement", poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +231,23 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.resultExpression != null && poco.resultExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("resultExpression", poco.resultExpression.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -205,9 +255,17 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
@@ -218,7 +276,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -229,7 +287,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculation != null)
                 {
@@ -240,7 +298,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -251,7 +309,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -262,7 +320,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -273,7 +331,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -284,7 +342,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -295,7 +353,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -306,7 +364,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -317,7 +375,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -328,7 +386,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -339,7 +397,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -350,7 +408,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -361,7 +419,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -372,18 +430,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -394,23 +452,29 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -421,7 +485,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -432,7 +496,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -443,7 +507,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -454,18 +518,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -476,7 +540,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -487,7 +551,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -498,7 +562,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -509,26 +573,26 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -539,40 +603,40 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -583,7 +647,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -594,7 +658,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -605,18 +669,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -627,18 +691,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -649,18 +713,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -671,29 +735,29 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -704,7 +768,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -715,7 +779,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -726,7 +790,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -737,7 +801,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -752,11 +816,11 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -767,7 +831,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -778,18 +842,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -800,18 +864,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -822,18 +886,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -844,7 +908,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -855,7 +919,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -866,7 +930,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -877,7 +941,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -888,36 +952,29 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -928,23 +985,29 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.resultExpression != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.resultExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -955,15 +1018,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -974,7 +1040,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -985,7 +1051,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -996,7 +1062,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1007,13 +1073,13 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1028,18 +1094,11 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, st
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAnalysisCaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AnalysisCaseDefinition");
@@ -1071,7 +1130,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefiniti
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1079,7 +1138,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefiniti
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1089,7 +1148,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefiniti
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1097,7 +1156,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefiniti
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1115,7 +1174,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefiniti
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1123,7 +1190,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefiniti
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "objectiveRequirement", null, poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1131,7 +1230,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefiniti
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.resultExpression != null && poco.resultExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "resultExpression", null, poco.resultExpression.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1139,545 +1254,559 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefiniti
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "action", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculation != null)
                 {
                     foreach (var item in poco.calculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "calculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1686,268 +1815,270 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseDefiniti
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.resultExpression != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.resultExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs
index b87ee7283..bdd2a4fca 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnalysisCaseUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.AnalysisCases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AnalysisCaseUsageWriter" /> is to write an instance of <see cref="IAnalysisCaseUsage" />
@@ -98,17 +99,10 @@ public AnalysisCaseUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAnalysisCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AnalysisCaseUsage");
@@ -120,6 +114,22 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.analysisCaseDefinition != null && poco.analysisCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("analysisCaseDefinition", poco.analysisCaseDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +140,40 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +184,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +207,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +217,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -188,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -206,7 +243,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -219,9 +256,9 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -229,7 +266,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -237,7 +274,15 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -245,9 +290,84 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("objectiveRequirement", poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -255,7 +375,23 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.resultExpression != null && poco.resultExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("resultExpression", poco.resultExpression.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -263,9 +399,17 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -276,7 +420,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -287,15 +431,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.analysisCaseDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.analysisCaseDefinition, "analysisCaseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.analysisCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.analysisCaseDefinition, "analysisCaseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -306,15 +453,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -325,7 +475,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -336,7 +486,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -347,7 +497,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -358,15 +508,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -377,7 +530,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -388,15 +541,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -407,7 +563,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -418,15 +574,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -437,7 +596,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -448,7 +607,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -459,7 +618,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -470,18 +629,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -492,15 +651,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -511,7 +673,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -522,7 +684,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -533,7 +695,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -544,7 +706,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -555,7 +717,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -566,7 +728,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -577,18 +739,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -599,7 +761,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -610,7 +772,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -621,7 +783,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -632,7 +794,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -643,7 +805,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -654,7 +816,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -665,7 +827,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -676,7 +838,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -687,7 +849,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -698,7 +860,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -709,7 +871,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -720,7 +882,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -731,7 +893,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -742,7 +904,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -753,7 +915,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -764,7 +926,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -775,7 +937,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -786,7 +948,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -797,15 +959,18 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -816,7 +981,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -827,67 +992,67 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -898,7 +1063,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -909,99 +1074,99 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1009,127 +1174,121 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1140,31 +1299,40 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.resultExpression != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.resultExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1175,7 +1343,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1186,7 +1354,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1197,7 +1365,7 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1208,13 +1376,13 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1229,18 +1397,11 @@ public override void Write(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAnalysisCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AnalysisCaseUsage");
@@ -1252,6 +1413,22 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.analysisCaseDefinition != null && poco.analysisCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "analysisCaseDefinition", null, poco.analysisCaseDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1262,13 +1439,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1279,7 +1483,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1302,7 +1506,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1312,7 +1516,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1320,7 +1524,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1338,7 +1542,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1351,9 +1555,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1361,7 +1565,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1369,7 +1573,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1377,9 +1589,84 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "objectiveRequirement", null, poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1387,7 +1674,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.resultExpression != null && poco.resultExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "resultExpression", null, poco.resultExpression.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1395,745 +1698,774 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.analysisCaseDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.analysisCaseDefinition, "analysisCaseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.analysisCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.analysisCaseDefinition, "analysisCaseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2141,212 +2473,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnalysisCaseUsage po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.resultExpression != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.resultExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.resultExpression, "resultExpression", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs
index 8b5a1c68d..19db5c1b7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotatingElementWriter.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AnnotatingElementWriter" /> is to write an instance of <see cref="IAnnotatingElement" />
@@ -68,17 +69,10 @@ public AnnotatingElementWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAnnotatingElement" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AnnotatingElement");
@@ -105,12 +99,12 @@ public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -118,7 +112,7 @@ public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -126,7 +120,23 @@ public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -134,7 +144,7 @@ public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -144,18 +154,18 @@ public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
@@ -166,7 +176,7 @@ public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -177,35 +187,35 @@ public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -214,48 +224,33 @@ public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -276,18 +271,11 @@ public override void Write(XmlWriter xmlWriter, IAnnotatingElement poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAnnotatingElement" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotatingElement poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotatingElement poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AnnotatingElement");
@@ -314,12 +302,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotatingElement po
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -327,7 +315,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotatingElement po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -335,7 +323,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotatingElement po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -343,7 +347,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotatingElement po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -353,68 +357,68 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotatingElement po
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "annotatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -423,54 +427,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotatingElement po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs
index 194d2ef71..c42a6d450 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AnnotationWriter.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AnnotationWriter" /> is to write an instance of <see cref="IAnnotation" />
@@ -68,17 +69,10 @@ public AnnotationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAnnotation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAnnotation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAnnotation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Annotation");
@@ -90,6 +84,19 @@ public override void Write(XmlWriter xmlWriter, IAnnotation poco, string element
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.AnnotatedElement != null && poco.AnnotatedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("annotatedElement", poco.AnnotatedElement.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.annotatingElement != null && poco.annotatingElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("annotatingElement", poco.annotatingElement.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -110,12 +117,12 @@ public override void Write(XmlWriter xmlWriter, IAnnotation poco, string element
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -123,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IAnnotation poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -131,7 +138,31 @@ public override void Write(XmlWriter xmlWriter, IAnnotation poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedAnnotatingElement != null && poco.ownedAnnotatingElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedAnnotatingElement", poco.ownedAnnotatingElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -139,7 +170,7 @@ public override void Write(XmlWriter xmlWriter, IAnnotation poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -151,18 +182,24 @@ public override void Write(XmlWriter xmlWriter, IAnnotation poco, string element
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.AnnotatedElement != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.AnnotatedElement, "annotatedElement", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.AnnotatedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.AnnotatedElement, "annotatedElement", elementOriginMap, currentFileUri, true);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotatingElement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.annotatingElement, "annotatingElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.annotatingElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.annotatingElement, "annotatingElement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -173,32 +210,32 @@ public override void Write(XmlWriter xmlWriter, IAnnotation poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingElement != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedAnnotatingElement, "ownedAnnotatingElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedAnnotatingElement, "ownedAnnotatingElement", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -207,7 +244,7 @@ public override void Write(XmlWriter xmlWriter, IAnnotation poco, string element
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -215,72 +252,44 @@ public override void Write(XmlWriter xmlWriter, IAnnotation poco, string element
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatedElement != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatedElement, "owningAnnotatedElement", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingElement != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingElement, "owningAnnotatingElement", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -301,18 +310,11 @@ public override void Write(XmlWriter xmlWriter, IAnnotation poco, string element
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAnnotation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Annotation");
@@ -324,6 +326,19 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.AnnotatedElement != null && poco.AnnotatedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "annotatedElement", null, poco.AnnotatedElement.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.annotatingElement != null && poco.annotatingElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "annotatingElement", null, poco.annotatingElement.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -344,12 +359,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -357,7 +372,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -365,7 +380,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedAnnotatingElement != null && poco.ownedAnnotatingElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedAnnotatingElement", null, poco.ownedAnnotatingElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -373,7 +412,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -385,54 +424,60 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, str
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.AnnotatedElement != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.AnnotatedElement, "annotatedElement", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.AnnotatedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.AnnotatedElement, "annotatedElement", elementOriginMap, currentFileUri, true);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotatingElement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.annotatingElement, "annotatingElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.annotatingElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.annotatingElement, "annotatingElement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingElement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedAnnotatingElement, "ownedAnnotatingElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedAnnotatingElement, "ownedAnnotatingElement", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -441,7 +486,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, str
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -449,78 +494,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAnnotation poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatedElement != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatedElement, "owningAnnotatedElement", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingElement != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingElement, "owningAnnotatingElement", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs
index fb100b14d..4fa5747bc 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssertConstraintUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Constraints;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AssertConstraintUsageWriter" /> is to write an instance of <see cref="IAssertConstraintUsage" />
@@ -98,17 +99,10 @@ public AssertConstraintUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAssertConstraintUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AssertConstraintUsage");
@@ -120,6 +114,30 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.assertedConstraint != null && poco.assertedConstraint.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("assertedConstraint", poco.assertedConstraint.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.constraintDefinition != null && poco.constraintDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("constraintDefinition", poco.constraintDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +148,40 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +192,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +215,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -188,7 +233,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -211,7 +256,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -224,9 +269,9 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -234,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -242,7 +287,15 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -250,9 +303,76 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -260,7 +380,15 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -270,15 +398,18 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assertedConstraint != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.assertedConstraint, "assertedConstraint", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.assertedConstraint.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.assertedConstraint, "assertedConstraint", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -289,23 +420,29 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.constraintDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.constraintDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -316,7 +453,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -327,7 +464,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -338,7 +475,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -349,15 +486,18 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -368,7 +508,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -379,15 +519,18 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -398,7 +541,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -409,15 +552,18 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -428,7 +574,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -439,7 +585,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -450,7 +596,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -461,18 +607,18 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -483,15 +629,18 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -502,7 +651,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -513,7 +662,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -524,7 +673,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -535,7 +684,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -546,7 +695,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -557,7 +706,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -568,18 +717,18 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -590,7 +739,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -601,7 +750,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -612,7 +761,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -623,7 +772,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -634,7 +783,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -645,7 +794,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -656,7 +805,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -667,7 +816,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -678,7 +827,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -689,7 +838,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -700,7 +849,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -711,7 +860,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -722,7 +871,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -733,7 +882,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -744,7 +893,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -755,7 +904,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -766,7 +915,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -777,7 +926,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -788,7 +937,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -799,7 +948,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -810,67 +959,67 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -881,7 +1030,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -892,99 +1041,99 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -992,127 +1141,121 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1123,15 +1266,18 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1142,7 +1288,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1153,7 +1299,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1164,7 +1310,7 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1175,13 +1321,13 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1196,18 +1342,11 @@ public override void Write(XmlWriter xmlWriter, IAssertConstraintUsage poco, str
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAssertConstraintUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AssertConstraintUsage");
@@ -1219,6 +1358,30 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.assertedConstraint != null && poco.assertedConstraint.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "assertedConstraint", null, poco.assertedConstraint.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.constraintDefinition != null && poco.constraintDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "constraintDefinition", null, poco.constraintDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1229,13 +1392,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1246,7 +1436,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1269,7 +1459,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1279,7 +1469,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1287,7 +1477,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1310,7 +1500,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1323,9 +1513,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1333,7 +1523,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1341,7 +1531,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1349,9 +1547,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1359,7 +1624,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1369,721 +1642,742 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assertedConstraint != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.assertedConstraint, "assertedConstraint", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.assertedConstraint.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.assertedConstraint, "assertedConstraint", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.constraintDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.constraintDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2091,196 +2385,193 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssertConstraintUsag
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs
index d12f91d13..0ea59a98e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssignmentActionUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AssignmentActionUsageWriter" /> is to write an instance of <see cref="IAssignmentActionUsage" />
@@ -98,17 +99,10 @@ public AssignmentActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAssignmentActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AssignmentActionUsage");
@@ -120,6 +114,14 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +132,40 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +176,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +199,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -198,7 +227,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -211,9 +240,9 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -221,7 +250,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -229,7 +258,15 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -237,9 +274,76 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -247,7 +351,15 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referent != null && poco.referent.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("referent", poco.referent.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -255,9 +367,25 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetArgument != null && poco.targetArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("targetArgument", poco.targetArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.valueExpression != null && poco.valueExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("valueExpression", poco.valueExpression.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -268,7 +396,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -279,15 +407,18 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -298,7 +429,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -309,7 +440,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -320,7 +451,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -331,15 +462,18 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -350,7 +484,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -361,15 +495,18 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -380,7 +517,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -391,15 +528,18 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -410,7 +550,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -421,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -432,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -443,18 +583,18 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -465,15 +605,18 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -484,7 +627,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -495,7 +638,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -506,7 +649,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -517,7 +660,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -528,7 +671,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -539,7 +682,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -550,18 +693,18 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -572,7 +715,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -583,7 +726,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -594,7 +737,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -605,7 +748,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -616,7 +759,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -627,7 +770,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -638,7 +781,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -649,7 +792,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -660,7 +803,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -671,7 +814,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -682,7 +825,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -693,7 +836,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -704,7 +847,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -715,7 +858,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -726,7 +869,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -737,7 +880,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -748,7 +891,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -759,7 +902,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -770,7 +913,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -781,7 +924,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -792,67 +935,67 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -863,7 +1006,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -874,99 +1017,99 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -974,127 +1117,121 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1105,23 +1242,29 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referent != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referent.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetArgument, "targetArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetArgument, "targetArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1132,7 +1275,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1143,7 +1286,7 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1154,15 +1297,18 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.valueExpression != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.valueExpression, "valueExpression", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.valueExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.valueExpression, "valueExpression", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1173,13 +1319,13 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1194,18 +1340,11 @@ public override void Write(XmlWriter xmlWriter, IAssignmentActionUsage poco, str
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAssignmentActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AssignmentActionUsage");
@@ -1217,6 +1356,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1227,13 +1374,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1244,7 +1418,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1267,7 +1441,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1277,7 +1451,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1295,7 +1469,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1308,9 +1482,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1318,7 +1492,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1326,7 +1500,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1334,9 +1516,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1344,7 +1593,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referent != null && poco.referent.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "referent", null, poco.referent.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1352,718 +1609,749 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetArgument != null && poco.targetArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "targetArgument", null, poco.targetArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.valueExpression != null && poco.valueExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "valueExpression", null, poco.valueExpression.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2071,212 +2359,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssignmentActionUsag
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referent != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referent.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.referent, "referent", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetArgument, "targetArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.targetArgument, "targetArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.valueExpression != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.valueExpression, "valueExpression", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.valueExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.valueExpression, "valueExpression", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs
index 3eb03121a..d444056fa 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationStructureWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Associations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AssociationStructureWriter" /> is to write an instance of <see cref="IAssociationStructure" />
@@ -73,17 +74,10 @@ public AssociationStructureWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAssociationStructure" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AssociationStructure");
@@ -115,7 +109,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -128,12 +122,12 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -146,7 +140,15 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -154,7 +156,31 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -162,7 +188,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -170,9 +196,17 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceType", poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.associationEnd != null)
                 {
@@ -183,7 +217,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -194,7 +228,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -205,7 +239,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -216,7 +250,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -227,7 +261,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -238,7 +272,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -249,7 +283,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -260,7 +294,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -271,7 +305,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -282,7 +316,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -293,18 +327,18 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -315,15 +349,18 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -334,59 +371,59 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -397,7 +434,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -408,57 +445,57 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -467,7 +504,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -475,78 +512,66 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
@@ -557,15 +582,18 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
@@ -576,7 +604,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -587,7 +615,7 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -608,18 +636,11 @@ public override void Write(XmlWriter xmlWriter, IAssociationStructure poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAssociationStructure" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AssociationStructure");
@@ -651,7 +672,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -664,12 +685,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -682,7 +703,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -690,7 +719,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -698,7 +751,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -706,295 +759,306 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceType", null, poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.associationEnd != null)
                 {
                     foreach (var item in poco.associationEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "associationEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1003,7 +1067,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1011,125 +1075,116 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociationStructure
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs
index ff7908ce1..199c92563 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AssociationWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Associations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AssociationWriter" /> is to write an instance of <see cref="IAssociation" />
@@ -72,17 +73,10 @@ public AssociationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactor
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAssociation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAssociation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAssociation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Association");
@@ -114,7 +108,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -127,12 +121,12 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -145,7 +139,15 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -153,7 +155,31 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -161,7 +187,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -169,9 +195,17 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceType", poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.associationEnd != null)
                 {
@@ -182,7 +216,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -193,7 +227,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -204,7 +238,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -215,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -226,7 +260,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -237,7 +271,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -248,7 +282,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -259,7 +293,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -270,7 +304,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -281,7 +315,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -292,18 +326,18 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -314,15 +348,18 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -333,59 +370,59 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -396,7 +433,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -407,57 +444,57 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -466,7 +503,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -474,78 +511,66 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
@@ -556,15 +581,18 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
@@ -575,7 +603,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -586,7 +614,7 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -607,18 +635,11 @@ public override void Write(XmlWriter xmlWriter, IAssociation poco, string elemen
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAssociation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Association");
@@ -650,7 +671,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -663,12 +684,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -681,7 +702,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -689,7 +718,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -697,7 +750,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -705,295 +758,306 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, st
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceType", null, poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.associationEnd != null)
                 {
                     foreach (var item in poco.associationEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "associationEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1002,7 +1066,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, st
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1010,125 +1074,116 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAssociation poco, st
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs
index d168f5cc9..6912cb629 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Attributes;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AttributeDefinitionWriter" /> is to write an instance of <see cref="IAttributeDefinition" />
@@ -94,17 +95,10 @@ public AttributeDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAttributeDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AttributeDefinition");
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,12 +138,12 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -167,7 +161,15 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -175,7 +177,31 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -183,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -193,7 +219,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -204,7 +230,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -215,7 +241,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -226,7 +252,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -237,7 +263,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -248,7 +274,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -259,7 +285,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -270,7 +296,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -281,7 +307,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -292,7 +318,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -303,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -314,7 +340,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -325,18 +351,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -347,15 +373,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -366,7 +395,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -377,7 +406,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -388,7 +417,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -399,18 +428,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -421,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -432,7 +461,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -443,7 +472,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -454,26 +483,26 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -484,40 +513,40 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -528,7 +557,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -539,7 +568,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -550,18 +579,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -572,18 +601,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -594,18 +623,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -616,29 +645,29 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -649,7 +678,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -660,7 +689,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -671,7 +700,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -682,7 +711,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -697,11 +726,11 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -712,7 +741,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -723,18 +752,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -745,18 +774,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -767,18 +796,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -789,7 +818,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -800,7 +829,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -811,7 +840,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -822,7 +851,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -833,36 +862,29 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -873,7 +895,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -884,7 +906,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -895,7 +917,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -906,13 +928,13 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -927,18 +949,11 @@ public override void Write(XmlWriter xmlWriter, IAttributeDefinition poco, strin
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAttributeDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AttributeDefinition");
@@ -970,7 +985,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -978,12 +993,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeDefinition
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1001,7 +1016,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1009,7 +1032,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1017,7 +1064,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1027,502 +1074,505 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeDefinition
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1531,222 +1581,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeDefinition
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs
index 8f3021b2e..8984c57da 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/AttributeUsageWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Attributes;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="AttributeUsageWriter" /> is to write an instance of <see cref="IAttributeUsage" />
@@ -95,17 +96,10 @@ public AttributeUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAttributeUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:AttributeUsage");
@@ -117,6 +111,14 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -127,13 +129,32 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -144,7 +165,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -167,12 +188,12 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -190,11 +211,11 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    xmlWriter.WriteAttributeString("isReference", "true");
+                    xmlWriter.WriteAttributeString("isReference", "false");
                 }
             }
 
@@ -203,9 +224,9 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -213,7 +234,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -221,7 +242,15 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -229,7 +258,71 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -237,7 +330,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -247,7 +340,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.attributeDefinition != null)
                 {
@@ -258,7 +351,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -269,15 +362,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -288,7 +384,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -299,7 +395,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -310,7 +406,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -321,7 +417,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -332,15 +428,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -351,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -362,15 +461,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -381,7 +483,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -392,7 +494,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -403,7 +505,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -414,7 +516,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -425,7 +527,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -436,18 +538,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -458,15 +560,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -477,7 +582,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -488,7 +593,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -499,7 +604,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -510,7 +615,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -521,7 +626,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -532,7 +637,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -543,18 +648,18 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -565,7 +670,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -576,7 +681,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -587,7 +692,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -598,7 +703,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -609,7 +714,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -620,7 +725,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -631,7 +736,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -642,7 +747,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -653,7 +758,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -664,7 +769,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -675,7 +780,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -686,7 +791,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -697,7 +802,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -708,7 +813,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -719,7 +824,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -730,7 +835,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -741,7 +846,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -752,7 +857,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -763,7 +868,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -774,67 +879,67 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -845,7 +950,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -856,99 +961,99 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -956,127 +1061,121 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1087,7 +1186,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1098,7 +1197,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1109,7 +1208,7 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1120,13 +1219,13 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1141,18 +1240,11 @@ public override void Write(XmlWriter xmlWriter, IAttributeUsage poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IAttributeUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:AttributeUsage");
@@ -1164,6 +1256,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1174,13 +1274,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1191,7 +1310,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1214,12 +1333,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1237,11 +1356,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "false");
                 }
             }
 
@@ -1250,9 +1369,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1260,7 +1379,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1268,7 +1387,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1276,7 +1403,71 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1284,7 +1475,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1294,708 +1485,720 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.attributeDefinition != null)
                 {
                     foreach (var item in poco.attributeDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "attributeDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "attributeDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2003,177 +2206,171 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IAttributeUsage poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs
index c87c9cb8b..85b7b4791 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BehaviorWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Behaviors;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="BehaviorWriter" /> is to write an instance of <see cref="IBehavior" />
@@ -73,17 +74,10 @@ public BehaviorWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory l
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IBehavior" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Behavior");
@@ -115,7 +109,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -123,12 +117,12 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -141,7 +135,15 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -149,7 +151,31 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -157,7 +183,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -167,7 +193,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -178,7 +204,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -189,7 +215,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -200,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -211,7 +237,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -222,7 +248,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -233,7 +259,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -244,7 +270,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -255,7 +281,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -266,7 +292,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -277,18 +303,18 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -299,15 +325,18 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -318,59 +347,59 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -381,7 +410,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -392,57 +421,57 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -451,73 +480,66 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -528,7 +550,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -539,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -550,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -571,18 +593,11 @@ public override void Write(XmlWriter xmlWriter, IBehavior poco, string elementNa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IBehavior" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IBehavior poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IBehavior poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Behavior");
@@ -614,7 +629,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBehavior poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -622,12 +637,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBehavior poco, strin
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -640,7 +655,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBehavior poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -648,7 +671,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBehavior poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -656,7 +703,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBehavior poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -666,282 +713,285 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBehavior poco, strin
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -950,112 +1000,105 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBehavior poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs
index d0dae240c..5d8c80995 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorAsUsageWriter.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Connections;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="BindingConnectorAsUsageWriter" /> is to write an instance of <see cref="IBindingConnectorAsUsage" />
@@ -96,17 +97,10 @@ public BindingConnectorAsUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, I
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IBindingConnectorAsUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:BindingConnectorAsUsage");
@@ -118,6 +112,14 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -128,13 +130,40 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -145,7 +174,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -173,12 +202,12 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -196,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -209,9 +238,9 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -219,7 +248,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -227,7 +256,15 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -235,7 +272,71 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -243,7 +344,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -251,9 +352,17 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.association != null)
                 {
@@ -264,7 +373,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -275,7 +384,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -286,23 +395,29 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.definition != null)
                 {
@@ -313,7 +428,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -324,7 +439,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -335,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -346,7 +461,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -357,15 +472,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -376,7 +494,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -387,15 +505,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -406,7 +527,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -417,7 +538,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -428,7 +549,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -439,7 +560,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -450,7 +571,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -461,18 +582,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -483,15 +604,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -502,7 +626,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -513,7 +637,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -524,7 +648,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -535,7 +659,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -546,7 +670,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -557,7 +681,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -568,18 +692,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -590,7 +714,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -601,7 +725,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -612,7 +736,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -623,7 +747,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -634,7 +758,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -645,7 +769,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -656,7 +780,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -667,7 +791,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -678,7 +802,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -689,7 +813,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -700,7 +824,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -711,7 +835,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -722,7 +846,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -733,7 +857,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -744,7 +868,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -755,7 +879,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -766,7 +890,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -777,7 +901,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -788,7 +912,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -799,67 +923,67 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -870,7 +994,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -881,99 +1005,99 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -981,7 +1105,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -989,132 +1113,121 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -1125,15 +1238,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -1144,7 +1260,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1155,7 +1271,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1166,7 +1282,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1177,7 +1293,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1188,13 +1304,13 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1209,18 +1325,11 @@ public override void Write(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, s
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IBindingConnectorAsUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:BindingConnectorAsUsage");
@@ -1232,6 +1341,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1242,13 +1359,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1259,7 +1403,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1287,12 +1431,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1310,7 +1454,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1323,9 +1467,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1333,7 +1477,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1341,7 +1485,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1349,7 +1501,71 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1357,7 +1573,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1365,729 +1581,752 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.association != null)
                 {
                     foreach (var item in poco.association)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "association", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.definition != null)
                 {
                     foreach (var item in poco.definition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "definition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2095,7 +2334,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -2103,212 +2342,204 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnectorAsUs
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs
index 336dbe87e..acf605745 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BindingConnectorWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Connectors;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="BindingConnectorWriter" /> is to write an instance of <see cref="IBindingConnector" />
@@ -73,17 +74,10 @@ public BindingConnectorWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IBindingConnector" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:BindingConnector");
@@ -95,6 +89,14 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -105,13 +107,40 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -122,7 +151,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -150,12 +179,12 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -178,9 +207,9 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -188,7 +217,15 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -196,7 +233,55 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -204,7 +289,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -212,9 +297,17 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.association != null)
                 {
@@ -225,7 +318,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -236,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -247,23 +340,29 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -274,7 +373,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -285,7 +384,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -296,15 +395,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -315,7 +417,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -326,15 +428,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -345,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -356,7 +461,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -367,7 +472,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -378,7 +483,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -389,7 +494,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -400,18 +505,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -422,15 +527,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -441,67 +549,67 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -512,7 +620,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -523,99 +631,99 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -623,7 +731,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -631,116 +739,99 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -751,15 +842,18 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -770,7 +864,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -781,7 +875,7 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -802,18 +896,11 @@ public override void Write(XmlWriter xmlWriter, IBindingConnector poco, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IBindingConnector" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:BindingConnector");
@@ -825,6 +912,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -835,13 +930,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -852,7 +974,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -880,12 +1002,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -908,9 +1030,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -918,7 +1040,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -926,7 +1056,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -934,7 +1112,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -942,410 +1120,433 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.association != null)
                 {
                     foreach (var item in poco.association)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "association", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1353,7 +1554,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1361,163 +1562,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBindingConnector poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs
index b810da3b5..f17cf69cf 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/BooleanExpressionWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="BooleanExpressionWriter" /> is to write an instance of <see cref="IBooleanExpression" />
@@ -73,17 +74,10 @@ public BooleanExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IBooleanExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:BooleanExpression");
@@ -95,6 +89,14 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -105,13 +107,32 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -122,7 +143,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -145,12 +166,12 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -158,7 +179,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -181,9 +202,9 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -191,7 +212,15 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -199,7 +228,63 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.predicate != null && poco.predicate.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("predicate", poco.predicate.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -207,7 +292,15 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -217,7 +310,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -228,15 +321,18 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -247,7 +343,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -258,7 +354,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -269,15 +365,18 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -288,7 +387,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -299,15 +398,18 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -318,7 +420,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -329,7 +431,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -340,7 +442,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -351,7 +453,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -362,7 +464,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -373,18 +475,18 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -395,15 +497,18 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -414,67 +519,67 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -485,7 +590,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -496,99 +601,99 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -596,111 +701,99 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -711,23 +804,29 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.predicate != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.predicate.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -738,7 +837,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -749,7 +848,7 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -770,18 +869,11 @@ public override void Write(XmlWriter xmlWriter, IBooleanExpression poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IBooleanExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:BooleanExpression");
@@ -793,6 +885,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -803,13 +903,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -820,7 +939,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -843,12 +962,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -856,7 +975,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -879,9 +998,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -889,7 +1008,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -897,7 +1024,63 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.predicate != null && poco.predicate.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "predicate", null, poco.predicate.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -905,7 +1088,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -915,378 +1106,390 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1294,166 +1497,160 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IBooleanExpression po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.predicate != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.predicate.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs
index 8acd43de0..0b739c5d7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationDefinitionWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Calculations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="CalculationDefinitionWriter" /> is to write an instance of <see cref="ICalculationDefinition" />
@@ -95,17 +96,10 @@ public CalculationDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICalculationDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CalculationDefinition");
@@ -137,7 +131,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -145,7 +139,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -155,7 +149,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -163,7 +157,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -181,7 +175,15 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -189,7 +191,31 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +223,15 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -207,7 +241,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
@@ -218,7 +252,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculation != null)
                 {
@@ -229,7 +263,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -240,7 +274,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -251,7 +285,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -262,7 +296,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -273,7 +307,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -284,7 +318,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -295,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -306,7 +340,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -317,7 +351,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -328,7 +362,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -339,7 +373,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -350,7 +384,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -361,18 +395,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -383,15 +417,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -402,7 +439,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -413,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -424,7 +461,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -435,18 +472,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -457,7 +494,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -468,7 +505,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -479,7 +516,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -490,26 +527,26 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -520,40 +557,40 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -564,7 +601,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -575,7 +612,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -586,18 +623,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -608,18 +645,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -630,18 +667,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -652,29 +689,29 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -685,7 +722,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -696,7 +733,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -707,7 +744,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -718,7 +755,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -733,11 +770,11 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -748,7 +785,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -759,18 +796,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -781,18 +818,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -803,18 +840,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -825,7 +862,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -836,7 +873,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -847,7 +884,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -858,7 +895,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -869,36 +906,29 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -909,15 +939,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -928,7 +961,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -939,7 +972,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -950,7 +983,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -961,7 +994,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -972,13 +1005,13 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -993,18 +1026,11 @@ public override void Write(XmlWriter xmlWriter, ICalculationDefinition poco, str
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICalculationDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CalculationDefinition");
@@ -1036,7 +1062,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinitio
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1044,7 +1070,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinitio
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1054,7 +1080,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinitio
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1062,7 +1088,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinitio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1080,7 +1106,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinitio
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1088,7 +1122,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinitio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1096,7 +1154,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinitio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1106,524 +1172,527 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinitio
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "action", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculation != null)
                 {
                     foreach (var item in poco.calculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "calculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1632,252 +1701,248 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationDefinitio
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs
index 3f06c0251..39111e63c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CalculationUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Calculations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="CalculationUsageWriter" /> is to write an instance of <see cref="ICalculationUsage" />
@@ -98,17 +99,10 @@ public CalculationUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICalculationUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CalculationUsage");
@@ -120,6 +114,22 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.calculationDefinition != null && poco.calculationDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("calculationDefinition", poco.calculationDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +140,40 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +184,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +207,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +217,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -188,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -206,7 +243,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -219,9 +256,9 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -229,7 +266,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -237,7 +274,15 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -245,9 +290,76 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -255,7 +367,15 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -265,7 +385,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -276,15 +396,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculationDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.calculationDefinition, "calculationDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.calculationDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.calculationDefinition, "calculationDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -295,15 +418,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -314,7 +440,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -325,7 +451,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -336,7 +462,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -347,15 +473,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -366,7 +495,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -377,15 +506,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -396,7 +528,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -407,15 +539,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -426,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -437,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -448,7 +583,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -459,18 +594,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -481,15 +616,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -500,7 +638,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -511,7 +649,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -522,7 +660,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -533,7 +671,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -544,7 +682,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -555,7 +693,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -566,18 +704,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -588,7 +726,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -599,7 +737,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -610,7 +748,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -621,7 +759,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -632,7 +770,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -643,7 +781,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -654,7 +792,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -665,7 +803,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -676,7 +814,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -687,7 +825,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -698,7 +836,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -709,7 +847,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -720,7 +858,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -731,7 +869,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -742,7 +880,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -753,7 +891,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -764,7 +902,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -775,7 +913,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -786,7 +924,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -797,7 +935,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -808,67 +946,67 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -879,7 +1017,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -890,99 +1028,99 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -990,127 +1128,121 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1121,15 +1253,18 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1140,7 +1275,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1151,7 +1286,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1162,7 +1297,7 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1173,13 +1308,13 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1194,18 +1329,11 @@ public override void Write(XmlWriter xmlWriter, ICalculationUsage poco, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICalculationUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CalculationUsage");
@@ -1217,6 +1345,22 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.calculationDefinition != null && poco.calculationDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "calculationDefinition", null, poco.calculationDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1227,13 +1371,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1244,7 +1415,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1267,7 +1438,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1277,7 +1448,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1285,7 +1456,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1303,7 +1474,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1316,9 +1487,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1326,7 +1497,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1334,7 +1505,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1342,9 +1521,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1352,7 +1598,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1362,724 +1616,742 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculationDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.calculationDefinition, "calculationDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.calculationDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.calculationDefinition, "calculationDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2087,196 +2359,193 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICalculationUsage poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs
index 567904778..47678d638 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseDefinitionWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Cases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="CaseDefinitionWriter" /> is to write an instance of <see cref="ICaseDefinition" />
@@ -95,17 +96,10 @@ public CaseDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CaseDefinition");
@@ -137,7 +131,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -145,7 +139,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -155,7 +149,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -163,7 +157,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -181,7 +175,15 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -189,7 +191,39 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("objectiveRequirement", poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +231,15 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -205,9 +247,17 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
@@ -218,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -229,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculation != null)
                 {
@@ -240,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -251,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -262,7 +312,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -273,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -284,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -295,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -306,7 +356,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -317,7 +367,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -328,7 +378,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -339,7 +389,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -350,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -361,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -372,18 +422,18 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -394,23 +444,29 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -421,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -432,7 +488,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -443,7 +499,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -454,18 +510,18 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -476,7 +532,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -487,7 +543,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -498,7 +554,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -509,26 +565,26 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -539,40 +595,40 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -583,7 +639,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -594,7 +650,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -605,18 +661,18 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -627,18 +683,18 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -649,18 +705,18 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -671,29 +727,29 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -704,7 +760,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -715,7 +771,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -726,7 +782,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -737,7 +793,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -752,11 +808,11 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -767,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -778,18 +834,18 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -800,18 +856,18 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -822,18 +878,18 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -844,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -855,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -866,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -877,7 +933,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -888,36 +944,29 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -928,15 +977,18 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -947,15 +999,18 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -966,7 +1021,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -977,7 +1032,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -988,7 +1043,7 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -999,13 +1054,13 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1020,18 +1075,11 @@ public override void Write(XmlWriter xmlWriter, ICaseDefinition poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CaseDefinition");
@@ -1063,7 +1111,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1071,7 +1119,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco,
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1081,7 +1129,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1089,7 +1137,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1107,7 +1155,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1115,7 +1171,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "objectiveRequirement", null, poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1123,7 +1211,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1131,545 +1227,559 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco,
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "action", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculation != null)
                 {
                     foreach (var item in poco.calculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "calculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1678,260 +1788,259 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseDefinition poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs
index ab6187521..e0f529925 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CaseUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Cases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="CaseUsageWriter" /> is to write an instance of <see cref="ICaseUsage" />
@@ -98,17 +99,10 @@ public CaseUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CaseUsage");
@@ -120,6 +114,22 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.caseDefinition != null && poco.caseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("caseDefinition", poco.caseDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +140,40 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +184,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +207,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +217,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -188,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -206,7 +243,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -219,9 +256,9 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -229,7 +266,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -237,7 +274,15 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -245,9 +290,84 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("objectiveRequirement", poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -255,7 +375,15 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -263,9 +391,17 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -276,7 +412,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -287,15 +423,18 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.caseDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.caseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -306,15 +445,18 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -325,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -336,7 +478,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -347,7 +489,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -358,15 +500,18 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -377,7 +522,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -388,15 +533,18 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -407,7 +555,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -418,15 +566,18 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -437,7 +588,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -448,7 +599,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -459,7 +610,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -470,18 +621,18 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -492,15 +643,18 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -511,7 +665,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -522,7 +676,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -533,7 +687,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -544,7 +698,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -555,7 +709,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -566,7 +720,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -577,18 +731,18 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -599,7 +753,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -610,7 +764,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -621,7 +775,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -632,7 +786,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -643,7 +797,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -654,7 +808,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -665,7 +819,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -676,7 +830,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -687,7 +841,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -698,7 +852,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -709,7 +863,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -720,7 +874,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -731,7 +885,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -742,7 +896,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -753,7 +907,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -764,7 +918,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -775,7 +929,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -786,7 +940,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -797,15 +951,18 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -816,7 +973,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -827,67 +984,67 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -898,7 +1055,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -909,99 +1066,99 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1009,127 +1166,121 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1140,23 +1291,29 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1167,7 +1324,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1178,7 +1335,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1189,7 +1346,7 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1200,13 +1357,13 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1221,18 +1378,11 @@ public override void Write(XmlWriter xmlWriter, ICaseUsage poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CaseUsage");
@@ -1244,6 +1394,22 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.caseDefinition != null && poco.caseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "caseDefinition", null, poco.caseDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1254,13 +1420,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1271,7 +1464,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1294,7 +1487,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1304,7 +1497,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1312,7 +1505,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1330,7 +1523,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1343,9 +1536,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1353,7 +1546,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1361,7 +1554,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1369,9 +1570,84 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "objectiveRequirement", null, poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1379,7 +1655,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1387,745 +1671,774 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.caseDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.caseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2133,204 +2446,204 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICaseUsage poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs
index b5a1e2d54..a30436fb1 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Classes;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ClassWriter" /> is to write an instance of <see cref="IClass" />
@@ -72,17 +73,10 @@ public ClassWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory logg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IClass" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IClass poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IClass poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Class");
@@ -114,7 +108,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -122,12 +116,12 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -140,7 +134,15 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -148,7 +150,31 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -156,7 +182,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -166,7 +192,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -177,7 +203,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -188,7 +214,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -199,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -210,7 +236,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -221,7 +247,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -232,7 +258,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -243,7 +269,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -254,7 +280,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -265,7 +291,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -276,7 +302,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -287,18 +313,18 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -309,15 +335,18 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -328,59 +357,59 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -391,7 +420,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -402,57 +431,57 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -461,73 +490,66 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -538,7 +560,7 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -559,18 +581,11 @@ public override void Write(XmlWriter xmlWriter, IClass poco, string elementName,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IClass" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IClass poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IClass poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Class");
@@ -602,7 +617,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClass poco, string e
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -610,12 +625,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClass poco, string e
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -628,7 +643,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClass poco, string e
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -636,7 +659,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClass poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -644,7 +691,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClass poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -654,293 +701,296 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClass poco, string e
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -949,90 +999,83 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClass poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs
index 1c7e04d04..4c7f739f1 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ClassifierWriter.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ClassifierWriter" /> is to write an instance of <see cref="IClassifier" />
@@ -71,17 +72,10 @@ public ClassifierWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IClassifier" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IClassifier poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IClassifier poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Classifier");
@@ -113,7 +107,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -121,12 +115,12 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -139,7 +133,15 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -147,7 +149,31 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -155,7 +181,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -165,7 +191,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -176,7 +202,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -187,7 +213,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -198,7 +224,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -209,7 +235,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -220,7 +246,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -231,7 +257,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -242,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -253,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -264,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -275,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -286,18 +312,18 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -308,15 +334,18 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -327,59 +356,59 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -390,7 +419,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -401,57 +430,57 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -460,73 +489,66 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -537,7 +559,7 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -558,18 +580,11 @@ public override void Write(XmlWriter xmlWriter, IClassifier poco, string element
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IClassifier" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IClassifier poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IClassifier poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Classifier");
@@ -601,7 +616,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClassifier poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -609,12 +624,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClassifier poco, str
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -627,7 +642,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClassifier poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -635,7 +658,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClassifier poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -643,7 +690,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClassifier poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -653,293 +700,296 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClassifier poco, str
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -948,90 +998,83 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IClassifier poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs
index 6185bd188..fa51abcee 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CollectExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="CollectExpressionWriter" /> is to write an instance of <see cref="ICollectExpression" />
@@ -74,17 +75,10 @@ public CollectExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICollectExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CollectExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,48 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("instantiatedType", poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +160,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +183,12 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +196,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +219,9 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +229,15 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,12 +245,63 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            if (poco.Operator != "collect")
+            {
+                if (!string.IsNullOrWhiteSpace(poco.Operator))
+                {
+                    xmlWriter.WriteAttributeString("operator", poco.Operator);
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
-                xmlWriter.WriteAttributeString("operator", poco.Operator);
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -213,7 +309,15 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -223,7 +327,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
@@ -234,7 +338,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -245,15 +349,18 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -264,7 +371,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -275,7 +382,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -286,15 +393,18 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -305,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -316,15 +426,18 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -335,15 +448,18 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -354,7 +470,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -365,7 +481,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -376,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -387,15 +503,18 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -406,18 +525,18 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -428,15 +547,18 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -447,67 +569,67 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -518,7 +640,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -529,99 +651,99 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -629,111 +751,99 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -744,15 +854,18 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -763,7 +876,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -774,7 +887,7 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -795,18 +908,11 @@ public override void Write(XmlWriter xmlWriter, ICollectExpression poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICollectExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CollectExpression");
@@ -818,6 +924,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -828,13 +942,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "instantiatedType", null, poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -845,7 +994,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -868,12 +1017,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -881,7 +1030,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -904,9 +1053,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -914,7 +1063,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -922,12 +1079,63 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
                 }
             }
 
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            if (poco.Operator != "collect")
+            {
+                if (!string.IsNullOrWhiteSpace(poco.Operator))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -935,7 +1143,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -945,405 +1161,423 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1351,158 +1585,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICollectExpression po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs
index e180af501..0dd0c7f9b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CommentWriter.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="CommentWriter" /> is to write an instance of <see cref="IComment" />
@@ -68,17 +69,10 @@ public CommentWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory lo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IComment" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IComment poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IComment poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Comment");
@@ -110,12 +104,12 @@ public override void Write(XmlWriter xmlWriter, IComment poco, string elementNam
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -128,7 +122,7 @@ public override void Write(XmlWriter xmlWriter, IComment poco, string elementNam
                 xmlWriter.WriteAttributeString("locale", poco.Locale);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -136,7 +130,23 @@ public override void Write(XmlWriter xmlWriter, IComment poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -144,7 +154,7 @@ public override void Write(XmlWriter xmlWriter, IComment poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -154,18 +164,18 @@ public override void Write(XmlWriter xmlWriter, IComment poco, string elementNam
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
@@ -176,7 +186,7 @@ public override void Write(XmlWriter xmlWriter, IComment poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -187,35 +197,35 @@ public override void Write(XmlWriter xmlWriter, IComment poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -224,48 +234,33 @@ public override void Write(XmlWriter xmlWriter, IComment poco, string elementNam
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -286,18 +281,11 @@ public override void Write(XmlWriter xmlWriter, IComment poco, string elementNam
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IComment" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IComment poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IComment poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Comment");
@@ -329,12 +317,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IComment poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -347,7 +335,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IComment poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "locale", null, poco.Locale);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -355,7 +343,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IComment poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -363,7 +367,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IComment poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -373,68 +377,68 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IComment poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "annotatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -443,54 +447,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IComment poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs
index 520990734..6d2f0371e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernDefinitionWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConcernDefinitionWriter" /> is to write an instance of <see cref="IConcernDefinition" />
@@ -95,17 +96,10 @@ public ConcernDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConcernDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConcernDefinition");
@@ -132,7 +126,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -140,7 +134,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -150,7 +144,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -158,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -176,7 +170,15 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -184,7 +186,31 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +223,15 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 xmlWriter.WriteAttributeString("reqId", poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -205,7 +239,15 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -215,7 +257,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -226,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
@@ -237,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -248,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -259,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -270,7 +312,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -281,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -292,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -303,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -314,7 +356,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
@@ -325,7 +367,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -336,7 +378,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -347,7 +389,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -358,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -369,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -380,18 +422,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -402,15 +444,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -421,7 +466,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -432,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -443,7 +488,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -454,18 +499,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -476,7 +521,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -487,7 +532,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -498,7 +543,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -509,26 +554,26 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -539,40 +584,40 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -583,7 +628,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -594,7 +639,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -605,18 +650,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -627,18 +672,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -649,18 +694,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -671,29 +716,29 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -704,7 +749,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -715,7 +760,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -726,7 +771,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -737,7 +782,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -752,11 +797,11 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -767,7 +812,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -778,18 +823,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -800,18 +845,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -822,18 +867,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -844,7 +889,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -855,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -866,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -877,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -888,36 +933,29 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -928,7 +966,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
@@ -939,15 +977,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
@@ -958,7 +999,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -969,15 +1010,18 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -988,7 +1032,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -999,7 +1043,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1010,7 +1054,7 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1021,13 +1065,13 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1042,18 +1086,11 @@ public override void Write(XmlWriter xmlWriter, IConcernDefinition poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConcernDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConcernDefinition");
@@ -1080,7 +1117,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition po
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1088,7 +1125,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition po
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1098,7 +1135,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition po
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1106,7 +1143,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1124,7 +1161,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition po
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1132,7 +1177,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1145,7 +1214,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition po
                 await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1153,7 +1230,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -1163,535 +1248,538 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition po
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1700,282 +1788,281 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernDefinition po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs
index a941e3afd..5e6c2bf72 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConcernUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConcernUsageWriter" /> is to write an instance of <see cref="IConcernUsage" />
@@ -98,17 +99,10 @@ public ConcernUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFacto
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConcernUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConcernUsage");
@@ -120,18 +114,61 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.concernDefinition != null && poco.concernDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("concernDefinition", poco.concernDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -142,7 +179,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -165,7 +202,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -175,7 +212,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -183,7 +220,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -201,7 +238,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -214,9 +251,9 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -224,7 +261,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -232,7 +269,15 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -240,9 +285,76 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -255,7 +367,15 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 xmlWriter.WriteAttributeString("reqId", poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -263,7 +383,15 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -273,7 +401,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -284,7 +412,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
@@ -295,7 +423,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -306,23 +434,29 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.concernDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.concernDefinition, "concernDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.concernDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.concernDefinition, "concernDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -333,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -344,7 +478,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -355,7 +489,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -366,15 +500,18 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -385,7 +522,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -396,15 +533,18 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -415,7 +555,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
@@ -426,7 +566,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -437,15 +577,18 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -456,7 +599,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -467,7 +610,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -478,7 +621,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -489,18 +632,18 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -511,15 +654,18 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -530,7 +676,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -541,7 +687,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -552,7 +698,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -563,7 +709,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -574,7 +720,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -585,7 +731,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -596,18 +742,18 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -618,7 +764,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -629,7 +775,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -640,7 +786,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -651,7 +797,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -662,7 +808,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -673,7 +819,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -684,7 +830,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -695,7 +841,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -706,7 +852,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -717,7 +863,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -728,7 +874,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -739,7 +885,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -750,7 +896,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -761,7 +907,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -772,7 +918,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -783,7 +929,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -794,7 +940,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -805,7 +951,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -816,7 +962,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -827,7 +973,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -838,67 +984,67 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -909,7 +1055,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -920,99 +1066,99 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1020,127 +1166,121 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1151,7 +1291,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
@@ -1162,15 +1302,18 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
@@ -1181,15 +1324,18 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1200,7 +1346,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1211,7 +1357,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1222,7 +1368,7 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1233,13 +1379,13 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1254,18 +1400,11 @@ public override void Write(XmlWriter xmlWriter, IConcernUsage poco, string eleme
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConcernUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConcernUsage");
@@ -1277,18 +1416,61 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.concernDefinition != null && poco.concernDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "concernDefinition", null, poco.concernDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1299,7 +1481,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1322,7 +1504,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1332,7 +1514,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1340,7 +1522,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1358,7 +1540,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1371,9 +1553,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1381,7 +1563,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1389,7 +1571,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1397,9 +1587,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1412,7 +1669,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1420,7 +1685,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -1430,746 +1703,764 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.concernDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.concernDefinition, "concernDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.concernDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.concernDefinition, "concernDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2177,226 +2468,226 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConcernUsage poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs
index 6b249d205..418f9580a 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortDefinitionWriter.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Ports;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConjugatedPortDefinitionWriter" /> is to write an instance of <see cref="IConjugatedPortDefinition" />
@@ -93,17 +94,10 @@ public ConjugatedPortDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConjugatedPortDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConjugatedPortDefinition");
@@ -115,6 +109,14 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.conjugatedPortDefinition != null && poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("conjugatedPortDefinition", poco.conjugatedPortDefinition.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -135,7 +137,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -143,7 +145,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -153,7 +155,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -171,7 +173,15 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -179,7 +189,31 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.originalPortDefinition != null && poco.originalPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("originalPortDefinition", poco.originalPortDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedPortConjugator != null && poco.ownedPortConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedPortConjugator", poco.ownedPortConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -187,7 +221,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -197,15 +231,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.conjugatedPortDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -216,7 +253,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -227,7 +264,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -238,7 +275,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -249,7 +286,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -260,7 +297,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -271,7 +308,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -282,7 +319,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -293,7 +330,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -304,7 +341,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -315,7 +352,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -326,7 +363,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -337,18 +374,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -359,23 +396,29 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.originalPortDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.originalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.originalPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.originalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -386,7 +429,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -397,7 +440,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -408,7 +451,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -419,18 +462,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -441,7 +484,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -452,7 +495,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -463,7 +506,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -474,18 +517,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -496,40 +539,40 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -540,7 +583,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -551,7 +594,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -562,18 +605,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -584,18 +627,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -606,18 +649,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -628,29 +671,29 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -661,7 +704,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -672,7 +715,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -683,7 +726,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -694,15 +737,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPortConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ownedPortConjugator, "ownedPortConjugator", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.ownedPortConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ownedPortConjugator, "ownedPortConjugator", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -717,11 +763,11 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -732,7 +778,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -743,18 +789,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -765,18 +811,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -787,18 +833,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -809,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -820,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -831,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -842,7 +888,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -853,28 +899,18 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -885,7 +921,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -896,7 +932,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -907,7 +943,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -918,13 +954,13 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -939,18 +975,11 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortDefinition poco,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConjugatedPortDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConjugatedPortDefinition");
@@ -962,6 +991,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefini
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.conjugatedPortDefinition != null && poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "conjugatedPortDefinition", null, poco.conjugatedPortDefinition.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -982,7 +1019,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefini
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -990,7 +1027,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefini
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1000,7 +1037,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefini
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1018,7 +1055,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefini
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1026,7 +1071,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefini
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.originalPortDefinition != null && poco.originalPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "originalPortDefinition", null, poco.originalPortDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedPortConjugator != null && poco.ownedPortConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedPortConjugator", null, poco.ownedPortConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1034,7 +1103,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefini
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1044,518 +1113,530 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefini
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.conjugatedPortDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.originalPortDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.originalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.originalPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.originalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPortConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ownedPortConjugator, "ownedPortConjugator", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.ownedPortConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ownedPortConjugator, "ownedPortConjugator", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1564,214 +1645,204 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortDefini
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs
index fa74fe71b..96ae1b678 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugatedPortTypingWriter.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Ports;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConjugatedPortTypingWriter" /> is to write an instance of <see cref="IConjugatedPortTyping" />
@@ -71,17 +72,10 @@ public ConjugatedPortTypingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConjugatedPortTyping" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConjugatedPortTyping");
@@ -93,6 +87,11 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.ConjugatedPortDefinition != null && poco.ConjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("conjugatedPortDefinition", poco.ConjugatedPortDefinition.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -113,12 +112,12 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -126,7 +125,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -134,7 +133,31 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.portDefinition != null && poco.portDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("portDefinition", poco.portDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -142,7 +165,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -150,14 +173,22 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.TypedFeature != null && poco.TypedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("typedFeature", poco.TypedFeature.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.ConjugatedPortDefinition != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ConjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -168,24 +199,24 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -194,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -202,72 +233,55 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeature != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.portDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.portDefinition, "portDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.portDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.portDefinition, "portDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -280,7 +294,10 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
 
             if (poco.TypedFeature != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.TypedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+                }
             }
 
 
@@ -293,18 +310,11 @@ public override void Write(XmlWriter xmlWriter, IConjugatedPortTyping poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConjugatedPortTyping" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConjugatedPortTyping");
@@ -316,6 +326,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.ConjugatedPortDefinition != null && poco.ConjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "conjugatedPortDefinition", null, poco.ConjugatedPortDefinition.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -336,12 +351,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -349,7 +364,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -357,7 +372,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.portDefinition != null && poco.portDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "portDefinition", null, poco.portDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -365,7 +404,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -373,42 +412,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.TypedFeature != null && poco.TypedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "typedFeature", null, poco.TypedFeature.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.ConjugatedPortDefinition != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ConjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ConjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ConjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -417,7 +464,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -425,85 +472,71 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugatedPortTyping
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeature != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.portDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.portDefinition, "portDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.portDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.portDefinition, "portDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
             if (poco.TypedFeature != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.TypedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+                }
             }
 
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs
index 4f70a33b2..493b0ac3c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConjugationWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConjugationWriter" /> is to write an instance of <see cref="IConjugation" />
@@ -69,17 +70,10 @@ public ConjugationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactor
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConjugation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConjugation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConjugation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Conjugation");
@@ -91,6 +85,11 @@ public override void Write(XmlWriter xmlWriter, IConjugation poco, string elemen
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.ConjugatedType != null && poco.ConjugatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("conjugatedType", poco.ConjugatedType.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -111,12 +110,12 @@ public override void Write(XmlWriter xmlWriter, IConjugation poco, string elemen
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +123,7 @@ public override void Write(XmlWriter xmlWriter, IConjugation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -132,7 +131,28 @@ public override void Write(XmlWriter xmlWriter, IConjugation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.WriteIdRefAsAttribute && poco.OriginalType != null && poco.OriginalType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("originalType", poco.OriginalType.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -140,7 +160,7 @@ public override void Write(XmlWriter xmlWriter, IConjugation poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -152,10 +172,13 @@ public override void Write(XmlWriter xmlWriter, IConjugation poco, string elemen
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.ConjugatedType != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ConjugatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -168,27 +191,30 @@ public override void Write(XmlWriter xmlWriter, IConjugation poco, string elemen
 
             if (poco.OriginalType != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OriginalType, "originalType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.OriginalType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OriginalType, "originalType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -197,7 +223,7 @@ public override void Write(XmlWriter xmlWriter, IConjugation poco, string elemen
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -205,64 +231,44 @@ public override void Write(XmlWriter xmlWriter, IConjugation poco, string elemen
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -283,18 +289,11 @@ public override void Write(XmlWriter xmlWriter, IConjugation poco, string elemen
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConjugation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Conjugation");
@@ -306,6 +305,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.ConjugatedType != null && poco.ConjugatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "conjugatedType", null, poco.ConjugatedType.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -326,12 +330,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -339,7 +343,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -347,7 +351,28 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.WriteIdRefAsAttribute && poco.OriginalType != null && poco.OriginalType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "originalType", null, poco.OriginalType.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -355,7 +380,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -367,43 +392,49 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, st
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.ConjugatedType != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ConjugatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
             if (poco.OriginalType != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OriginalType, "originalType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.OriginalType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.OriginalType, "originalType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -412,7 +443,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, st
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -420,70 +451,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConjugation poco, st
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs
index ca0365011..c9ff4c792 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Connections;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConnectionDefinitionWriter" /> is to write an instance of <see cref="IConnectionDefinition" />
@@ -94,17 +95,10 @@ public ConnectionDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConnectionDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConnectionDefinition");
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -149,7 +143,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -159,7 +153,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -167,9 +161,9 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (poco.IsSufficient)
+            if (!poco.IsSufficient)
             {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
+                xmlWriter.WriteAttributeString("isSufficient", "false");
             }
 
             if (poco.IsVariation)
@@ -177,7 +171,15 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -185,7 +187,31 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -193,7 +219,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -201,9 +227,17 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceType", poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectionEnd != null)
                 {
@@ -214,7 +248,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -225,7 +259,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -236,7 +270,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -247,7 +281,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -258,7 +292,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -269,7 +303,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -280,7 +314,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -291,7 +325,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -302,7 +336,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -313,7 +347,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -324,7 +358,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -335,18 +369,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -357,15 +391,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -376,7 +413,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -387,7 +424,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -398,7 +435,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -409,18 +446,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -431,7 +468,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -442,7 +479,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -453,7 +490,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -464,26 +501,26 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -494,40 +531,40 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -538,7 +575,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -549,7 +586,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -560,18 +597,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -582,18 +619,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -604,18 +641,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -626,29 +663,29 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -659,7 +696,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -670,7 +707,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -681,7 +718,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -692,7 +729,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -707,7 +744,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -715,11 +752,11 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -730,7 +767,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -741,18 +778,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -763,18 +800,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -785,18 +822,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -807,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -818,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -829,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -840,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -851,41 +888,29 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
@@ -896,15 +921,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
@@ -915,7 +943,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -926,7 +954,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -937,7 +965,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -948,7 +976,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -959,13 +987,13 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -980,18 +1008,11 @@ public override void Write(XmlWriter xmlWriter, IConnectionDefinition poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConnectionDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConnectionDefinition");
@@ -1023,7 +1044,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1036,7 +1057,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1046,7 +1067,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1054,9 +1075,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition
                 }
             }
 
-            if (poco.IsSufficient)
+            if (!poco.IsSufficient)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1064,7 +1085,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1072,7 +1101,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1080,7 +1133,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1088,504 +1141,515 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceType", null, poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectionEnd != null)
                 {
                     foreach (var item in poco.connectionEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectionEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectionEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1594,7 +1658,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1602,257 +1666,248 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionDefinition
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs
index d2d5989d6..934ee87dc 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectionUsageWriter.cs
@@ -69,6 +69,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Connections;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConnectionUsageWriter" /> is to write an instance of <see cref="IConnectionUsage" />
@@ -99,17 +100,10 @@ public ConnectionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConnectionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConnectionUsage");
@@ -121,6 +115,14 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -131,13 +133,48 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -148,7 +185,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -176,7 +213,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -186,7 +223,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -204,7 +241,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -217,9 +254,9 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -227,7 +264,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -235,7 +272,15 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -243,9 +288,76 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -253,7 +365,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -261,9 +373,17 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -274,7 +394,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectionDefinition != null)
                 {
@@ -285,7 +405,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -296,23 +416,29 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -323,7 +449,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -334,7 +460,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -345,7 +471,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -356,15 +482,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -375,7 +504,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -386,15 +515,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -405,7 +537,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -416,15 +548,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -435,7 +570,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -446,7 +581,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -457,7 +592,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -468,7 +603,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
@@ -479,18 +614,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -501,15 +636,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -520,7 +658,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -531,7 +669,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -542,7 +680,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -553,7 +691,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -564,7 +702,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -575,7 +713,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -586,18 +724,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -608,7 +746,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -619,7 +757,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -630,7 +768,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -641,7 +779,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -652,7 +790,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -663,7 +801,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -674,7 +812,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -685,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -696,7 +834,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -707,7 +845,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -718,7 +856,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -729,7 +867,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -740,7 +878,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -751,7 +889,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -762,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -773,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -784,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -795,7 +933,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -806,7 +944,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -817,7 +955,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -828,67 +966,67 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -899,7 +1037,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -910,99 +1048,99 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1010,7 +1148,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1018,132 +1156,121 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.partDefinition != null)
                 {
@@ -1154,7 +1281,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -1165,15 +1292,18 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -1184,7 +1314,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1195,7 +1325,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1206,7 +1336,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1217,7 +1347,7 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1228,13 +1358,13 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1249,18 +1379,11 @@ public override void Write(XmlWriter xmlWriter, IConnectionUsage poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConnectionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConnectionUsage");
@@ -1272,6 +1395,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1282,13 +1413,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1299,7 +1465,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1327,7 +1493,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1337,7 +1503,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1355,7 +1521,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1368,9 +1534,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1378,7 +1544,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1386,7 +1552,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1394,9 +1568,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1404,7 +1645,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1412,748 +1653,774 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectionDefinition != null)
                 {
                     foreach (var item in poco.connectionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2161,7 +2428,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -2169,223 +2436,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnectionUsage poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.partDefinition != null)
                 {
                     foreach (var item in poco.partDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "partDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs
index 242a7d9ff..ac0d7fa21 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConnectorWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Connectors;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConnectorWriter" /> is to write an instance of <see cref="IConnector" />
@@ -73,17 +74,10 @@ public ConnectorWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConnector" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConnector poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConnector poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Connector");
@@ -95,6 +89,14 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -105,13 +107,40 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -122,7 +151,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -150,12 +179,12 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -178,9 +207,9 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -188,7 +217,15 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -196,7 +233,55 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -204,7 +289,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -212,9 +297,17 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.association != null)
                 {
@@ -225,7 +318,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -236,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -247,23 +340,29 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -274,7 +373,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -285,7 +384,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -296,15 +395,18 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -315,7 +417,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -326,15 +428,18 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -345,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -356,7 +461,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -367,7 +472,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -378,7 +483,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -389,7 +494,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -400,18 +505,18 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -422,15 +527,18 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -441,67 +549,67 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -512,7 +620,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -523,99 +631,99 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -623,7 +731,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -631,116 +739,99 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -751,15 +842,18 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -770,7 +864,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -781,7 +875,7 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -802,18 +896,11 @@ public override void Write(XmlWriter xmlWriter, IConnector poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConnector" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Connector");
@@ -825,6 +912,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -835,13 +930,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -852,7 +974,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -880,12 +1002,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -908,9 +1030,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -918,7 +1040,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -926,7 +1056,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -934,7 +1112,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -942,410 +1120,433 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.association != null)
                 {
                     foreach (var item in poco.association)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "association", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1353,7 +1554,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1361,163 +1562,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConnector poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs
index 7d2e2f6e2..ef46223a7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintDefinitionWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Constraints;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConstraintDefinitionWriter" /> is to write an instance of <see cref="IConstraintDefinition" />
@@ -95,17 +96,10 @@ public ConstraintDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConstraintDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConstraintDefinition");
@@ -137,7 +131,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -145,7 +139,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -155,7 +149,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -163,7 +157,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -181,7 +175,15 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -189,7 +191,31 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +223,15 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -207,7 +241,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -218,7 +252,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -229,7 +263,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -240,7 +274,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -251,7 +285,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -262,7 +296,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -273,7 +307,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -284,7 +318,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -295,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -306,7 +340,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -317,7 +351,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -328,7 +362,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -339,18 +373,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -361,15 +395,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -380,7 +417,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -391,7 +428,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -402,7 +439,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -413,18 +450,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -435,7 +472,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -446,7 +483,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -457,7 +494,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -468,26 +505,26 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -498,40 +535,40 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -542,7 +579,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -553,7 +590,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -564,18 +601,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -586,18 +623,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -608,18 +645,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -630,29 +667,29 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -663,7 +700,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -674,7 +711,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -685,7 +722,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -696,7 +733,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -711,11 +748,11 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -726,7 +763,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -737,18 +774,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -759,18 +796,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -781,18 +818,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -803,7 +840,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -814,7 +851,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -825,7 +862,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -836,7 +873,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -847,36 +884,29 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -887,15 +917,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -906,7 +939,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -917,7 +950,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -928,7 +961,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -939,7 +972,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -950,13 +983,13 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -971,18 +1004,11 @@ public override void Write(XmlWriter xmlWriter, IConstraintDefinition poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConstraintDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConstraintDefinition");
@@ -1014,7 +1040,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1022,7 +1048,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1032,7 +1058,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1040,7 +1066,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1058,7 +1084,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1066,7 +1100,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1074,7 +1132,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1084,502 +1150,505 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1588,252 +1657,248 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintDefinition
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs
index 93b6038b7..1ee39d713 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstraintUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Constraints;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConstraintUsageWriter" /> is to write an instance of <see cref="IConstraintUsage" />
@@ -98,17 +99,10 @@ public ConstraintUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConstraintUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConstraintUsage");
@@ -120,6 +114,22 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.constraintDefinition != null && poco.constraintDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("constraintDefinition", poco.constraintDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +140,40 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +184,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +207,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +217,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -188,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -206,7 +243,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -219,9 +256,9 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -229,7 +266,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -237,7 +274,15 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -245,9 +290,76 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -255,7 +367,15 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -265,7 +385,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -276,23 +396,29 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.constraintDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.constraintDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -303,7 +429,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -314,7 +440,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -325,7 +451,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -336,15 +462,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -355,7 +484,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -366,15 +495,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -385,7 +517,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -396,15 +528,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -415,7 +550,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -426,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -437,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -448,18 +583,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -470,15 +605,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -489,7 +627,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -500,7 +638,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -511,7 +649,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -522,7 +660,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -533,7 +671,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -544,7 +682,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -555,18 +693,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -577,7 +715,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -588,7 +726,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -599,7 +737,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -610,7 +748,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -621,7 +759,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -632,7 +770,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -643,7 +781,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -654,7 +792,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -665,7 +803,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -676,7 +814,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -687,7 +825,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -698,7 +836,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -709,7 +847,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -720,7 +858,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -731,7 +869,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -742,7 +880,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -753,7 +891,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -764,7 +902,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -775,7 +913,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -786,7 +924,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -797,67 +935,67 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -868,7 +1006,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -879,99 +1017,99 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -979,127 +1117,121 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1110,15 +1242,18 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1129,7 +1264,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1140,7 +1275,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1151,7 +1286,7 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1162,13 +1297,13 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1183,18 +1318,11 @@ public override void Write(XmlWriter xmlWriter, IConstraintUsage poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConstraintUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConstraintUsage");
@@ -1206,6 +1334,22 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.constraintDefinition != null && poco.constraintDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "constraintDefinition", null, poco.constraintDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1216,13 +1360,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1233,7 +1404,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1256,7 +1427,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1266,7 +1437,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1274,7 +1445,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1292,7 +1463,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1305,9 +1476,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1315,7 +1486,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1323,7 +1494,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1331,9 +1510,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1341,7 +1587,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1351,713 +1605,731 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.constraintDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.constraintDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.constraintDefinition, "constraintDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2065,196 +2337,193 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstraintUsage poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs
index df033e4bc..4a62d4812 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ConstructorExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ConstructorExpressionWriter" /> is to write an instance of <see cref="IConstructorExpression" />
@@ -74,17 +75,10 @@ public ConstructorExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConstructorExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ConstructorExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,48 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("instantiatedType", poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +160,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +183,12 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +196,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +219,9 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +229,15 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +245,55 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +301,15 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -218,7 +319,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
@@ -229,7 +330,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -240,15 +341,18 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -259,7 +363,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -270,7 +374,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -281,15 +385,18 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -300,7 +407,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -311,15 +418,18 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -330,15 +440,18 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -349,7 +462,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -360,7 +473,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -371,7 +484,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -382,15 +495,18 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -401,18 +517,18 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -423,15 +539,18 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -442,67 +561,67 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -513,7 +632,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -524,99 +643,99 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -624,111 +743,99 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -739,15 +846,18 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -758,7 +868,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -769,7 +879,7 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -790,18 +900,11 @@ public override void Write(XmlWriter xmlWriter, IConstructorExpression poco, str
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IConstructorExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ConstructorExpression");
@@ -813,6 +916,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -823,13 +934,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "instantiatedType", null, poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -840,7 +986,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -863,12 +1009,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -876,7 +1022,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -899,9 +1045,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -909,7 +1055,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -917,7 +1071,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -925,7 +1127,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -935,405 +1145,423 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1341,158 +1569,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IConstructorExpressio
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs
index 4b4393ca4..a6bc60dd7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/CrossSubsettingWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="CrossSubsettingWriter" /> is to write an instance of <see cref="ICrossSubsetting" />
@@ -70,17 +71,10 @@ public CrossSubsettingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICrossSubsetting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:CrossSubsetting");
@@ -92,6 +86,11 @@ public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.CrossedFeature != null && poco.CrossedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("crossedFeature", poco.CrossedFeature.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -112,12 +111,12 @@ public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string el
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -125,7 +124,7 @@ public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -133,7 +132,23 @@ public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -141,7 +156,7 @@ public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -153,18 +168,13 @@ public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string el
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.CrossedFeature != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.CrossedFeature, "crossedFeature", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.crossingFeature != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.CrossedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossingFeature, "crossingFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.CrossedFeature, "crossedFeature", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -175,24 +185,24 @@ public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -201,7 +211,7 @@ public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string el
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -209,56 +219,44 @@ public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -279,18 +277,11 @@ public override void Write(XmlWriter xmlWriter, ICrossSubsetting poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ICrossSubsetting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:CrossSubsetting");
@@ -302,6 +293,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.CrossedFeature != null && poco.CrossedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "crossedFeature", null, poco.CrossedFeature.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -322,12 +318,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -335,7 +331,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -343,7 +339,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -351,7 +363,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -363,46 +375,41 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.CrossedFeature != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.CrossedFeature, "crossedFeature", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.crossingFeature != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.CrossedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossingFeature, "crossingFeature", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.CrossedFeature, "crossedFeature", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -411,7 +418,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -419,62 +426,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ICrossSubsetting poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs
index 6dfd50678..1685831ad 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DataTypeWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.DataTypes;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="DataTypeWriter" /> is to write an instance of <see cref="IDataType" />
@@ -72,17 +73,10 @@ public DataTypeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory l
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDataType" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IDataType poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDataType poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:DataType");
@@ -114,7 +108,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -122,12 +116,12 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -140,7 +134,15 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -148,7 +150,31 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -156,7 +182,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -166,7 +192,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -177,7 +203,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -188,7 +214,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -199,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -210,7 +236,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -221,7 +247,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -232,7 +258,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -243,7 +269,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -254,7 +280,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -265,7 +291,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -276,7 +302,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -287,18 +313,18 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -309,15 +335,18 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -328,59 +357,59 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -391,7 +420,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -402,57 +431,57 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -461,73 +490,66 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -538,7 +560,7 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -559,18 +581,11 @@ public override void Write(XmlWriter xmlWriter, IDataType poco, string elementNa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDataType" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IDataType poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDataType poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:DataType");
@@ -602,7 +617,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDataType poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -610,12 +625,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDataType poco, strin
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -628,7 +643,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDataType poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -636,7 +659,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDataType poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -644,7 +691,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDataType poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -654,293 +701,296 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDataType poco, strin
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -949,90 +999,83 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDataType poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs
index c28d4a215..ea35f4609 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DecisionNodeWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="DecisionNodeWriter" /> is to write an instance of <see cref="IDecisionNode" />
@@ -97,17 +98,10 @@ public DecisionNodeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFacto
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDecisionNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:DecisionNode");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,40 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +175,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +198,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -197,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -210,9 +239,9 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -220,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -228,7 +257,15 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -236,9 +273,76 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -246,7 +350,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -256,7 +360,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -267,7 +371,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -278,15 +382,18 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -297,7 +404,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -308,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -319,7 +426,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -330,15 +437,18 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -349,7 +459,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -360,15 +470,18 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -379,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -390,15 +503,18 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -409,7 +525,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -420,7 +536,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -431,7 +547,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -442,18 +558,18 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -464,15 +580,18 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -483,7 +602,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -494,7 +613,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -505,7 +624,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -516,7 +635,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -527,7 +646,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -538,7 +657,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -549,18 +668,18 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -571,7 +690,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -582,7 +701,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -593,7 +712,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -604,7 +723,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -615,7 +734,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -626,7 +745,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -637,7 +756,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -648,7 +767,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -659,7 +778,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -670,7 +789,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -681,7 +800,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -692,7 +811,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -703,7 +822,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -714,7 +833,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -725,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -736,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -747,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -758,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -769,7 +888,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -780,7 +899,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -791,67 +910,67 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -862,7 +981,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -873,99 +992,99 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -973,127 +1092,121 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1104,7 +1217,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1115,7 +1228,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1126,7 +1239,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1137,7 +1250,7 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1148,13 +1261,13 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1169,18 +1282,11 @@ public override void Write(XmlWriter xmlWriter, IDecisionNode poco, string eleme
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDecisionNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:DecisionNode");
@@ -1192,6 +1298,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1202,13 +1316,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1219,7 +1360,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1242,7 +1383,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1252,7 +1393,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1270,7 +1411,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1283,9 +1424,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1293,7 +1434,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1301,7 +1442,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1309,9 +1458,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1319,7 +1535,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1329,716 +1545,731 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2046,188 +2277,182 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDecisionNode poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs
index 9a2ad17b7..dac3a8cf1 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DefinitionWriter.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="DefinitionWriter" /> is to write an instance of <see cref="IDefinition" />
@@ -93,17 +94,10 @@ public DefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Definition");
@@ -135,7 +129,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -143,12 +137,12 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -166,7 +160,15 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -174,7 +176,31 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -182,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -192,7 +218,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -203,7 +229,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -214,7 +240,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -225,7 +251,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -236,7 +262,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -247,7 +273,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -258,7 +284,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -269,7 +295,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -280,7 +306,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -291,7 +317,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -302,7 +328,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -313,7 +339,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -324,18 +350,18 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -346,15 +372,18 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -365,7 +394,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -376,7 +405,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -387,7 +416,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -398,18 +427,18 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -420,7 +449,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -431,7 +460,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -442,7 +471,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -453,26 +482,26 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -483,40 +512,40 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -527,7 +556,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -538,7 +567,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -549,18 +578,18 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -571,18 +600,18 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -593,18 +622,18 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -615,29 +644,29 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -648,7 +677,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -659,7 +688,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -670,7 +699,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -681,7 +710,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -696,11 +725,11 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -711,7 +740,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -722,18 +751,18 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -744,18 +773,18 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -766,18 +795,18 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -788,7 +817,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -799,7 +828,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -810,7 +839,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -821,7 +850,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -832,36 +861,29 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -872,7 +894,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -883,7 +905,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -894,7 +916,7 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -905,13 +927,13 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -926,18 +948,11 @@ public override void Write(XmlWriter xmlWriter, IDefinition poco, string element
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Definition");
@@ -969,7 +984,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDefinition poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -977,12 +992,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDefinition poco, str
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1000,7 +1015,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDefinition poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1008,7 +1031,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1016,7 +1063,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1026,502 +1073,505 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDefinition poco, str
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1530,222 +1580,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDefinition poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs
index accd6045d..9697927d5 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DependencyWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Dependencies;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="DependencyWriter" /> is to write an instance of <see cref="IDependency" />
@@ -69,17 +70,10 @@ public DependencyWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDependency" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IDependency poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDependency poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Dependency");
@@ -111,12 +105,12 @@ public override void Write(XmlWriter xmlWriter, IDependency poco, string element
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +118,7 @@ public override void Write(XmlWriter xmlWriter, IDependency poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -132,7 +126,23 @@ public override void Write(XmlWriter xmlWriter, IDependency poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -140,7 +150,7 @@ public override void Write(XmlWriter xmlWriter, IDependency poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -154,11 +164,11 @@ public override void Write(XmlWriter xmlWriter, IDependency poco, string element
             {
                 foreach (var item in poco.Client)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "client", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "client", elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -169,24 +179,24 @@ public override void Write(XmlWriter xmlWriter, IDependency poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -195,7 +205,7 @@ public override void Write(XmlWriter xmlWriter, IDependency poco, string element
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -203,51 +213,39 @@ public override void Write(XmlWriter xmlWriter, IDependency poco, string element
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -256,11 +254,11 @@ public override void Write(XmlWriter xmlWriter, IDependency poco, string element
             {
                 foreach (var item in poco.Supplier)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "supplier", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "supplier", elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -281,18 +279,11 @@ public override void Write(XmlWriter xmlWriter, IDependency poco, string element
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDependency" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Dependency");
@@ -324,12 +315,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -337,7 +328,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -345,7 +336,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -353,7 +360,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -367,39 +374,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, str
             {
                 foreach (var item in poco.Client)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "client", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "client", elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -408,7 +415,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, str
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -416,51 +423,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -469,17 +464,17 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDependency poco, str
             {
                 foreach (var item in poco.Supplier)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "supplier", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "supplier", elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs
index fbe5fe8df..5b6aa50a3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DifferencingWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="DifferencingWriter" /> is to write an instance of <see cref="IDifferencing" />
@@ -69,17 +70,10 @@ public DifferencingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFacto
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDifferencing" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IDifferencing poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDifferencing poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Differencing");
@@ -101,6 +95,11 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.DifferencingType != null && poco.DifferencingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("differencingType", poco.DifferencingType.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
@@ -111,12 +110,12 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +123,7 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -132,7 +131,23 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -140,7 +155,7 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -152,10 +167,13 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.DifferencingType != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.DifferencingType, "differencingType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.DifferencingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.DifferencingType, "differencingType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -166,24 +184,24 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -192,7 +210,7 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -200,56 +218,44 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -260,14 +266,6 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.typeDifferenced != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeDifferenced, "typeDifferenced", elementOriginMap, currentFileUri);
-                }
-            }
-
 
             xmlWriter.WriteEndElement();
         }
@@ -278,18 +276,11 @@ public override void Write(XmlWriter xmlWriter, IDifferencing poco, string eleme
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDifferencing" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Differencing");
@@ -311,6 +302,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.DifferencingType != null && poco.DifferencingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "differencingType", null, poco.DifferencingType.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
@@ -321,12 +317,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -334,7 +330,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -342,7 +338,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -350,7 +362,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -362,38 +374,41 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, s
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.DifferencingType != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.DifferencingType, "differencingType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.DifferencingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.DifferencingType, "differencingType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -402,7 +417,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, s
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -410,74 +425,54 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDifferencing poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.typeDifferenced != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.typeDifferenced, "typeDifferenced", elementOriginMap, currentFileUri);
-                }
-            }
-
 
             await xmlWriter.WriteEndElementAsync();
         }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs
index 3afd0ae1f..2e9879780 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DisjoiningWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="DisjoiningWriter" /> is to write an instance of <see cref="IDisjoining" />
@@ -69,17 +70,10 @@ public DisjoiningWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDisjoining" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IDisjoining poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDisjoining poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Disjoining");
@@ -101,6 +95,11 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.DisjoiningType != null && poco.DisjoiningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("disjoiningType", poco.DisjoiningType.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
@@ -111,12 +110,12 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +123,7 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -132,7 +131,23 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -140,7 +155,7 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -148,14 +163,22 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.TypeDisjoined != null && poco.TypeDisjoined.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("typeDisjoined", poco.TypeDisjoined.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.DisjoiningType != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.DisjoiningType, "disjoiningType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.DisjoiningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.DisjoiningType, "disjoiningType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -166,24 +189,24 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -192,7 +215,7 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -200,64 +223,44 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -270,7 +273,10 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
 
             if (poco.TypeDisjoined != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypeDisjoined, "typeDisjoined", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.TypeDisjoined.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypeDisjoined, "typeDisjoined", elementOriginMap, currentFileUri);
+                }
             }
 
 
@@ -283,18 +289,11 @@ public override void Write(XmlWriter xmlWriter, IDisjoining poco, string element
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDisjoining" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Disjoining");
@@ -316,6 +315,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.DisjoiningType != null && poco.DisjoiningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "disjoiningType", null, poco.DisjoiningType.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
@@ -326,12 +330,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -339,7 +343,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -347,7 +351,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -355,7 +375,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -363,42 +383,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, str
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.TypeDisjoined != null && poco.TypeDisjoined.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "typeDisjoined", null, poco.TypeDisjoined.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.DisjoiningType != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.DisjoiningType, "disjoiningType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.DisjoiningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.DisjoiningType, "disjoiningType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -407,7 +435,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, str
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -415,77 +443,60 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDisjoining poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
             if (poco.TypeDisjoined != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.TypeDisjoined, "typeDisjoined", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.TypeDisjoined.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.TypeDisjoined, "typeDisjoined", elementOriginMap, currentFileUri);
+                }
             }
 
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs
index a7fb28e52..a4fa14655 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/DocumentationWriter.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="DocumentationWriter" /> is to write an instance of <see cref="IDocumentation" />
@@ -68,17 +69,10 @@ public DocumentationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFact
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDocumentation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Documentation");
@@ -105,17 +99,25 @@ public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elem
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.documentedElement != null && poco.documentedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("documentedElement", poco.documentedElement.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -128,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elem
                 xmlWriter.WriteAttributeString("locale", poco.Locale);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -136,7 +138,23 @@ public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -144,7 +162,7 @@ public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -154,7 +172,7 @@ public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elem
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
@@ -165,7 +183,7 @@ public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -176,43 +194,46 @@ public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentedElement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.documentedElement, "documentedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.documentedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.documentedElement, "documentedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -221,48 +242,33 @@ public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elem
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -283,18 +289,11 @@ public override void Write(XmlWriter xmlWriter, IDocumentation poco, string elem
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IDocumentation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IDocumentation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IDocumentation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Documentation");
@@ -321,17 +320,25 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDocumentation poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.documentedElement != null && poco.documentedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "documentedElement", null, poco.documentedElement.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -344,7 +351,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDocumentation poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "locale", null, poco.Locale);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -352,7 +359,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDocumentation poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -360,7 +383,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDocumentation poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -370,65 +393,68 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDocumentation poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentedElement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.documentedElement, "documentedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.documentedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.documentedElement, "documentedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -437,54 +463,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IDocumentation poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs
index 8a96c8ee6..c290127ab 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ElementFilterMembershipWriter.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Packages;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ElementFilterMembershipWriter" /> is to write an instance of <see cref="IElementFilterMembership" />
@@ -71,17 +72,10 @@ public ElementFilterMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, I
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IElementFilterMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ElementFilterMembership");
@@ -93,6 +87,14 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.condition != null && poco.condition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("condition", poco.condition.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -113,12 +115,12 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -126,7 +128,7 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -134,7 +136,7 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -142,7 +144,7 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -150,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -158,7 +160,23 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -166,7 +184,7 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -174,19 +192,22 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.condition != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.condition, "condition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.condition, "condition", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -197,32 +218,24 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.membershipOwningNamespace != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -231,7 +244,7 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -239,56 +252,44 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -309,18 +310,11 @@ public override void Write(XmlWriter xmlWriter, IElementFilterMembership poco, s
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IElementFilterMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ElementFilterMembership");
@@ -332,6 +326,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.condition != null && poco.condition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "condition", null, poco.condition.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -352,12 +354,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -365,7 +367,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -373,7 +375,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -381,7 +383,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -389,7 +391,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -397,7 +399,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -405,7 +423,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -413,55 +431,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.condition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.condition, "condition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.condition, "condition", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.membershipOwningNamespace != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -470,7 +483,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -478,62 +491,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IElementFilterMembers
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs
index 0b27ece6a..15ac12f49 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EndFeatureMembershipWriter.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="EndFeatureMembershipWriter" /> is to write an instance of <see cref="IEndFeatureMembership" />
@@ -71,17 +72,10 @@ public EndFeatureMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IEndFeatureMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EndFeatureMembership");
@@ -113,12 +107,12 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -126,7 +120,7 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -134,7 +128,7 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -142,7 +136,15 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedMemberFeature != null && poco.ownedMemberFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberFeature", poco.ownedMemberFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -150,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -158,7 +160,23 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -166,7 +184,7 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -174,11 +192,14 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -189,33 +210,33 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMemberFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -223,7 +244,7 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -231,64 +252,44 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -309,18 +310,11 @@ public override void Write(XmlWriter xmlWriter, IEndFeatureMembership poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IEndFeatureMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:EndFeatureMembership");
@@ -352,12 +346,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -365,7 +359,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -373,7 +367,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -381,7 +375,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedMemberFeature != null && poco.ownedMemberFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberFeature", null, poco.ownedMemberFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -389,7 +391,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -397,7 +399,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -405,7 +423,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -413,48 +431,51 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMemberFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedMemberFeature, "ownedMemberFeature", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -462,7 +483,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -470,70 +491,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEndFeatureMembership
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs
index a4917cdd3..d6b743634 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationDefinitionWriter.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Enumerations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="EnumerationDefinitionWriter" /> is to write an instance of <see cref="IEnumerationDefinition" />
@@ -93,17 +94,10 @@ public EnumerationDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IEnumerationDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EnumerationDefinition");
@@ -135,7 +129,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -143,12 +137,12 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -161,12 +155,20 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsVariation)
+            if (!poco.IsVariation)
             {
-                xmlWriter.WriteAttributeString("isVariation", "true");
+                xmlWriter.WriteAttributeString("isVariation", "false");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -174,7 +176,31 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -182,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -192,7 +218,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -203,7 +229,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -214,7 +240,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -225,7 +251,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -236,7 +262,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -247,7 +273,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.enumeratedValue != null)
                 {
@@ -258,7 +284,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -269,7 +295,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -280,7 +306,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -291,7 +317,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -302,7 +328,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -313,7 +339,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -324,7 +350,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -335,18 +361,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -357,15 +383,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -376,7 +405,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -387,7 +416,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -398,7 +427,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -409,18 +438,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -431,7 +460,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -442,7 +471,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -453,7 +482,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -464,26 +493,26 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -494,40 +523,40 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -538,7 +567,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -549,7 +578,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -560,18 +589,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -582,18 +611,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -604,18 +633,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -626,29 +655,29 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -659,7 +688,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -670,7 +699,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -681,7 +710,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -692,7 +721,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -707,11 +736,11 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -722,7 +751,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -733,18 +762,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -755,18 +784,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -777,18 +806,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -799,7 +828,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -810,7 +839,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -821,7 +850,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -832,7 +861,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -843,36 +872,29 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -883,7 +905,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -894,7 +916,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -905,13 +927,13 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -926,18 +948,11 @@ public override void Write(XmlWriter xmlWriter, IEnumerationDefinition poco, str
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IEnumerationDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:EnumerationDefinition");
@@ -969,7 +984,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationDefinitio
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -977,12 +992,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationDefinitio
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -995,12 +1010,20 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationDefinitio
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsVariation)
+            if (!poco.IsVariation)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "false");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1008,7 +1031,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationDefinitio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1016,7 +1063,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationDefinitio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1026,513 +1073,516 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationDefinitio
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.enumeratedValue != null)
                 {
                     foreach (var item in poco.enumeratedValue)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "enumeratedValue", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "enumeratedValue", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1541,211 +1591,204 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationDefinitio
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs
index cc76f671d..24a414510 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EnumerationUsageWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Enumerations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="EnumerationUsageWriter" /> is to write an instance of <see cref="IEnumerationUsage" />
@@ -95,17 +96,10 @@ public EnumerationUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IEnumerationUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EnumerationUsage");
@@ -117,6 +111,14 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -127,13 +129,40 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.enumerationDefinition != null && poco.enumerationDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("enumerationDefinition", poco.enumerationDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -144,7 +173,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -167,12 +196,12 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -190,11 +219,11 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    xmlWriter.WriteAttributeString("isReference", "true");
+                    xmlWriter.WriteAttributeString("isReference", "false");
                 }
             }
 
@@ -203,9 +232,9 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -213,7 +242,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -221,7 +250,15 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -229,7 +266,71 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -237,7 +338,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -247,7 +348,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -258,15 +359,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -277,7 +381,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -288,7 +392,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -299,7 +403,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -310,7 +414,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -321,23 +425,29 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.enumerationDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.enumerationDefinition, "enumerationDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.enumerationDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.enumerationDefinition, "enumerationDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -348,7 +458,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -359,15 +469,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -378,7 +491,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -389,7 +502,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -400,7 +513,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -411,7 +524,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -422,7 +535,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -433,18 +546,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -455,15 +568,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -474,7 +590,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -485,7 +601,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -496,7 +612,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -507,7 +623,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -518,7 +634,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -529,7 +645,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -540,18 +656,18 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -562,7 +678,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -573,7 +689,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -584,7 +700,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -595,7 +711,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -606,7 +722,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -617,7 +733,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -628,7 +744,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -639,7 +755,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -650,7 +766,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -661,7 +777,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -672,7 +788,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -683,7 +799,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -694,7 +810,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -705,7 +821,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -716,7 +832,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -727,7 +843,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -738,7 +854,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -749,7 +865,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -760,7 +876,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -771,67 +887,67 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -842,7 +958,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -853,99 +969,99 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -953,127 +1069,121 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1084,7 +1194,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1095,7 +1205,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1106,7 +1216,7 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1117,13 +1227,13 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1138,18 +1248,11 @@ public override void Write(XmlWriter xmlWriter, IEnumerationUsage poco, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IEnumerationUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:EnumerationUsage");
@@ -1161,6 +1264,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1171,13 +1282,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.enumerationDefinition != null && poco.enumerationDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "enumerationDefinition", null, poco.enumerationDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1188,7 +1326,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1211,12 +1349,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1234,11 +1372,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "false");
                 }
             }
 
@@ -1247,9 +1385,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1257,7 +1395,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1265,7 +1403,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1273,7 +1419,71 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1281,7 +1491,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1291,705 +1501,720 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.enumerationDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.enumerationDefinition, "enumerationDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.enumerationDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.enumerationDefinition, "enumerationDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1997,177 +2222,171 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEnumerationUsage poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs
index 72450b1ab..09bfe12ea 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/EventOccurrenceUsageWriter.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="EventOccurrenceUsageWriter" /> is to write an instance of <see cref="IEventOccurrenceUsage" />
@@ -96,17 +97,10 @@ public EventOccurrenceUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IEventOccurrenceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:EventOccurrenceUsage");
@@ -118,6 +112,14 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -128,13 +130,48 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.eventOccurrence != null && poco.eventOccurrence.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("eventOccurrence", poco.eventOccurrence.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -145,7 +182,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -168,7 +205,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -178,7 +215,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -196,11 +233,11 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    xmlWriter.WriteAttributeString("isReference", "true");
+                    xmlWriter.WriteAttributeString("isReference", "false");
                 }
             }
 
@@ -209,9 +246,9 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -219,7 +256,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -227,7 +264,15 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -235,9 +280,76 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -245,7 +357,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -255,7 +367,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -266,15 +378,18 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -285,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -296,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -307,7 +422,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -318,7 +433,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -329,23 +444,29 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.eventOccurrence != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.eventOccurrence, "eventOccurrence", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.eventOccurrence.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.eventOccurrence, "eventOccurrence", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -356,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -367,15 +488,18 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -386,7 +510,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -397,15 +521,18 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -416,7 +543,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -427,7 +554,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -438,7 +565,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -449,18 +576,18 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -471,15 +598,18 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -490,7 +620,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -501,7 +631,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -512,7 +642,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -523,7 +653,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -534,7 +664,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -545,7 +675,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -556,18 +686,18 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -578,7 +708,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -589,7 +719,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -600,7 +730,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -611,7 +741,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -622,7 +752,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -633,7 +763,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -644,7 +774,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -655,7 +785,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -666,7 +796,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -677,7 +807,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -688,7 +818,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -699,7 +829,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -710,7 +840,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -721,7 +851,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -732,7 +862,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -743,7 +873,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -754,7 +884,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -765,7 +895,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -776,7 +906,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -787,7 +917,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -798,67 +928,67 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -869,7 +999,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -880,99 +1010,99 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -980,127 +1110,121 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1111,7 +1235,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1122,7 +1246,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1133,7 +1257,7 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1144,13 +1268,13 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1165,18 +1289,11 @@ public override void Write(XmlWriter xmlWriter, IEventOccurrenceUsage poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IEventOccurrenceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:EventOccurrenceUsage");
@@ -1188,6 +1305,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1198,13 +1323,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.eventOccurrence != null && poco.eventOccurrence.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "eventOccurrence", null, poco.eventOccurrence.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1215,7 +1375,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1238,7 +1398,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1248,7 +1408,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1266,11 +1426,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "false");
                 }
             }
 
@@ -1279,9 +1439,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1289,7 +1449,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1297,7 +1457,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1305,9 +1473,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1315,7 +1550,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1325,724 +1560,742 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.eventOccurrence != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.eventOccurrence, "eventOccurrence", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.eventOccurrence.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.eventOccurrence, "eventOccurrence", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2050,177 +2303,171 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IEventOccurrenceUsage
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs
index 77084fc17..4cb1c0547 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExhibitStateUsageWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.States;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ExhibitStateUsageWriter" /> is to write an instance of <see cref="IExhibitStateUsage" />
@@ -97,17 +98,10 @@ public ExhibitStateUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IExhibitStateUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ExhibitStateUsage");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,72 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.doAction != null && poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("doAction", poco.doAction.Id.ToString());
+                }
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.entryAction != null && poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("entryAction", poco.entryAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.exhibitedState != null && poco.exhibitedState.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("exhibitedState", poco.exhibitedState.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.exitAction != null && poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("exitAction", poco.exitAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +207,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +230,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +240,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -202,11 +263,11 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    xmlWriter.WriteAttributeString("isReference", "true");
+                    xmlWriter.WriteAttributeString("isReference", "false");
                 }
             }
 
@@ -215,9 +276,9 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -225,7 +286,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -233,7 +294,15 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -241,9 +310,76 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -251,7 +387,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -261,7 +397,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -272,15 +408,18 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -291,7 +430,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -302,15 +441,18 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.doAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -321,7 +463,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -332,39 +474,51 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.entryAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.exhibitedState != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exhibitedState, "exhibitedState", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.exhibitedState.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exhibitedState, "exhibitedState", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.exitAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -375,7 +529,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -386,15 +540,18 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -405,7 +562,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -416,15 +573,18 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -435,7 +595,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -446,7 +606,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -457,7 +617,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -468,18 +628,18 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -490,15 +650,18 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -509,7 +672,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -520,7 +683,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -531,7 +694,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -542,7 +705,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -553,7 +716,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -564,7 +727,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -575,18 +738,18 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -597,7 +760,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -608,7 +771,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -619,7 +782,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -630,7 +793,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -641,7 +804,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -652,7 +815,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -663,7 +826,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -674,7 +837,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -685,7 +848,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -696,7 +859,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -707,7 +870,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -718,7 +881,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -729,7 +892,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -740,7 +903,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -751,7 +914,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -762,7 +925,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -773,7 +936,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -784,7 +947,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -795,7 +958,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -806,7 +969,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -817,67 +980,67 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -888,7 +1051,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -899,99 +1062,99 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -999,127 +1162,121 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1130,7 +1287,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stateDefinition != null)
                 {
@@ -1141,7 +1298,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1152,7 +1309,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1163,7 +1320,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1174,7 +1331,7 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1185,13 +1342,13 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1206,18 +1363,11 @@ public override void Write(XmlWriter xmlWriter, IExhibitStateUsage poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IExhibitStateUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ExhibitStateUsage");
@@ -1229,6 +1379,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1239,13 +1397,72 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.doAction != null && poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "doAction", null, poco.doAction.Id.ToString());
+                }
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.entryAction != null && poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "entryAction", null, poco.entryAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.exhibitedState != null && poco.exhibitedState.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "exhibitedState", null, poco.exhibitedState.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.exitAction != null && poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "exitAction", null, poco.exitAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1256,7 +1473,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1279,7 +1496,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1289,7 +1506,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1312,11 +1529,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "false");
                 }
             }
 
@@ -1325,9 +1542,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1335,7 +1552,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1343,7 +1560,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1351,9 +1576,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1361,7 +1653,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1371,737 +1663,764 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.doAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.entryAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.exhibitedState != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.exhibitedState, "exhibitedState", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.exhibitedState.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.exhibitedState, "exhibitedState", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.exitAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2109,199 +2428,193 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExhibitStateUsage po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stateDefinition != null)
                 {
                     foreach (var item in poco.stateDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stateDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "stateDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs
index 4de808076..82ed3aa55 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ExpressionWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ExpressionWriter" /> is to write an instance of <see cref="IExpression" />
@@ -73,17 +74,10 @@ public ExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Expression");
@@ -95,6 +89,14 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -105,13 +107,40 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -122,7 +151,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -145,12 +174,12 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -158,7 +187,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -181,9 +210,9 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -191,7 +220,15 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -199,7 +236,55 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -207,7 +292,15 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -217,7 +310,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -228,15 +321,18 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -247,7 +343,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -258,7 +354,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -269,15 +365,18 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -288,7 +387,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -299,15 +398,18 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -318,15 +420,18 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -337,7 +442,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -348,7 +453,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -359,7 +464,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -370,7 +475,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -381,18 +486,18 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -403,15 +508,18 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -422,67 +530,67 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -493,7 +601,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -504,99 +612,99 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -604,111 +712,99 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -719,15 +815,18 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -738,7 +837,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -749,7 +848,7 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -770,18 +869,11 @@ public override void Write(XmlWriter xmlWriter, IExpression poco, string element
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Expression");
@@ -793,6 +885,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -803,13 +903,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -820,7 +947,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -843,12 +970,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -856,7 +983,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -879,9 +1006,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -889,7 +1016,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -897,7 +1032,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -905,7 +1088,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -915,386 +1106,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1302,158 +1508,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IExpression poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs
index 5abfe1668..551369a20 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FeatureChainExpressionWriter" /> is to write an instance of <see cref="IFeatureChainExpression" />
@@ -74,17 +75,10 @@ public FeatureChainExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, IL
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureChainExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureChainExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,48 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("instantiatedType", poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +160,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +183,12 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +196,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +219,9 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +229,15 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,12 +245,63 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            if (poco.Operator != ".")
+            {
+                if (!string.IsNullOrWhiteSpace(poco.Operator))
+                {
+                    xmlWriter.WriteAttributeString("operator", poco.Operator);
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
-                xmlWriter.WriteAttributeString("operator", poco.Operator);
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -213,7 +309,15 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -221,9 +325,17 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetFeature != null && poco.targetFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("targetFeature", poco.targetFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
@@ -234,7 +346,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -245,15 +357,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -264,7 +379,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -275,7 +390,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -286,15 +401,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -305,7 +423,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -316,15 +434,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -335,15 +456,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -354,7 +478,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -365,7 +489,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -376,7 +500,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -387,15 +511,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -406,18 +533,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -428,15 +555,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -447,67 +577,67 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -518,7 +648,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -529,99 +659,99 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -629,111 +759,99 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -744,23 +862,29 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetFeature, "targetFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetFeature, "targetFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -771,7 +895,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -782,7 +906,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -803,18 +927,11 @@ public override void Write(XmlWriter xmlWriter, IFeatureChainExpression poco, st
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureChainExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureChainExpression");
@@ -826,6 +943,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -836,13 +961,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "instantiatedType", null, poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -853,7 +1013,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -876,12 +1036,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -889,7 +1049,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -912,9 +1072,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -922,7 +1082,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -930,12 +1098,63 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
                 }
             }
 
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            if (poco.Operator != ".")
+            {
+                if (!string.IsNullOrWhiteSpace(poco.Operator))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -943,7 +1162,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -951,407 +1178,433 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetFeature != null && poco.targetFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "targetFeature", null, poco.targetFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1359,166 +1612,160 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChainExpressi
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetFeature, "targetFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.targetFeature, "targetFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs
index e1084f51f..a4ef26bc5 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureChainingWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FeatureChainingWriter" /> is to write an instance of <see cref="IFeatureChaining" />
@@ -69,17 +70,10 @@ public FeatureChainingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureChaining" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureChaining");
@@ -91,6 +85,11 @@ public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.ChainingFeature != null && poco.ChainingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("chainingFeature", poco.ChainingFeature.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -111,12 +110,12 @@ public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string el
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +123,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -132,7 +131,23 @@ public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -140,7 +155,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -152,10 +167,13 @@ public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string el
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.ChainingFeature != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ChainingFeature, "chainingFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ChainingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ChainingFeature, "chainingFeature", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -166,32 +184,24 @@ public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.featureChained != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureChained, "featureChained", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -200,7 +210,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string el
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -208,56 +218,44 @@ public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -278,18 +276,11 @@ public override void Write(XmlWriter xmlWriter, IFeatureChaining poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureChaining" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureChaining");
@@ -301,6 +292,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.ChainingFeature != null && poco.ChainingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "chainingFeature", null, poco.ChainingFeature.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -321,12 +317,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -334,7 +330,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -342,7 +338,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -350,7 +362,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -362,46 +374,41 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco
             // Reference/containment properties as child elements (sorted alphabetically)
             if (poco.ChainingFeature != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ChainingFeature, "chainingFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ChainingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ChainingFeature, "chainingFeature", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.featureChained != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureChained, "featureChained", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -410,7 +417,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -418,62 +425,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureChaining poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs
index 546b7cb44..6369eae14 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureInvertingWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FeatureInvertingWriter" /> is to write an instance of <see cref="IFeatureInverting" />
@@ -69,17 +70,10 @@ public FeatureInvertingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureInverting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureInverting");
@@ -106,17 +100,27 @@ public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string e
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.FeatureInverted != null && poco.FeatureInverted.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("featureInverted", poco.FeatureInverted.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.InvertingFeature != null && poco.InvertingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("invertingFeature", poco.InvertingFeature.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +128,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -132,7 +136,23 @@ public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -140,7 +160,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -150,7 +170,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string e
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -163,32 +183,38 @@ public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string e
 
             if (poco.FeatureInverted != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeatureInverted, "featureInverted", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.FeatureInverted.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeatureInverted, "featureInverted", elementOriginMap, currentFileUri);
+                }
             }
 
             if (poco.InvertingFeature != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.InvertingFeature, "invertingFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.InvertingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.InvertingFeature, "invertingFeature", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -197,7 +223,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string e
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -205,64 +231,44 @@ public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeature != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -283,18 +289,11 @@ public override void Write(XmlWriter xmlWriter, IFeatureInverting poco, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureInverting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureInverting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureInverting poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureInverting");
@@ -321,17 +320,27 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureInverting poc
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.FeatureInverted != null && poco.FeatureInverted.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "featureInverted", null, poco.FeatureInverted.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.InvertingFeature != null && poco.InvertingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "invertingFeature", null, poco.InvertingFeature.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -339,7 +348,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureInverting poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -347,7 +356,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureInverting poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -355,7 +380,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureInverting poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -365,45 +390,51 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureInverting poc
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
             if (poco.FeatureInverted != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.FeatureInverted, "featureInverted", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.FeatureInverted.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.FeatureInverted, "featureInverted", elementOriginMap, currentFileUri);
+                }
             }
 
             if (poco.InvertingFeature != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.InvertingFeature, "invertingFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.InvertingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.InvertingFeature, "invertingFeature", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -412,7 +443,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureInverting poc
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -420,70 +451,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureInverting poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeature != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs
index 99ba7ee04..e824056d9 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureMembershipWriter.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FeatureMembershipWriter" /> is to write an instance of <see cref="IFeatureMembership" />
@@ -71,17 +72,10 @@ public FeatureMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureMembership");
@@ -113,12 +107,12 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -126,7 +120,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -134,7 +128,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -142,7 +136,15 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedMemberFeature != null && poco.ownedMemberFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberFeature", poco.ownedMemberFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -150,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -158,7 +160,23 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -166,7 +184,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -174,11 +192,14 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -189,33 +210,33 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMemberFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -223,7 +244,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -231,64 +252,44 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -309,18 +310,11 @@ public override void Write(XmlWriter xmlWriter, IFeatureMembership poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureMembership");
@@ -352,12 +346,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership po
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -365,7 +359,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -373,7 +367,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -381,7 +375,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedMemberFeature != null && poco.ownedMemberFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberFeature", null, poco.ownedMemberFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -389,7 +391,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -397,7 +399,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -405,7 +423,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -413,48 +431,51 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership po
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMemberFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedMemberFeature, "ownedMemberFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedMemberFeature, "ownedMemberFeature", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -462,7 +483,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership po
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -470,70 +491,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureMembership po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs
index ed6aa2d60..2a9790955 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureReferenceExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FeatureReferenceExpressionWriter" /> is to write an instance of <see cref="IFeatureReferenceExpression" />
@@ -74,17 +75,10 @@ public FeatureReferenceExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureReferenceExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureReferenceExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,40 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +175,12 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +188,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +211,9 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +221,15 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +237,55 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +293,23 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referent != null && poco.referent.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("referent", poco.referent.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -218,7 +319,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -229,15 +330,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -248,7 +352,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -259,7 +363,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -270,15 +374,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -289,7 +396,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -300,15 +407,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -319,15 +429,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -338,7 +451,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -349,7 +462,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -360,7 +473,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -371,7 +484,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -382,18 +495,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -404,15 +517,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -423,67 +539,67 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -494,7 +610,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -505,99 +621,99 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -605,111 +721,99 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -720,23 +824,29 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referent != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referent.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -747,7 +857,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -758,7 +868,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -779,18 +889,11 @@ public override void Write(XmlWriter xmlWriter, IFeatureReferenceExpression poco
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureReferenceExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureReferenceExpression");
@@ -802,6 +905,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -812,13 +923,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -829,7 +967,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -852,12 +990,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -865,7 +1003,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -888,9 +1026,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -898,7 +1036,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -906,7 +1052,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -914,7 +1108,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referent != null && poco.referent.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "referent", null, poco.referent.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -924,386 +1134,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1311,166 +1536,160 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureReferenceExpr
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referent != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referent, "referent", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referent.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.referent, "referent", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs
index 9575d8e97..6e6f394bf 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureTypingWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FeatureTypingWriter" /> is to write an instance of <see cref="IFeatureTyping" />
@@ -70,17 +71,10 @@ public FeatureTypingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFact
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureTyping" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureTyping");
@@ -112,12 +106,12 @@ public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elem
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -125,7 +119,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -133,7 +127,23 @@ public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -141,7 +151,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -149,9 +159,19 @@ public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elem
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.Type != null && poco.Type.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("type", poco.Type.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.TypedFeature != null && poco.TypedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("typedFeature", poco.TypedFeature.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -162,24 +182,24 @@ public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -188,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elem
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -196,64 +216,44 @@ public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elem
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeature != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -266,12 +266,18 @@ public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elem
 
             if (poco.Type != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Type, "type", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.Type.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Type, "type", elementOriginMap, currentFileUri);
+                }
             }
 
             if (poco.TypedFeature != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.TypedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+                }
             }
 
 
@@ -284,18 +290,11 @@ public override void Write(XmlWriter xmlWriter, IFeatureTyping poco, string elem
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureTyping" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureTyping poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureTyping poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureTyping");
@@ -327,12 +326,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureTyping poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -340,7 +339,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureTyping poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -348,7 +347,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureTyping poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -356,7 +371,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureTyping poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -364,37 +379,47 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureTyping poco,
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.Type != null && poco.Type.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "type", null, poco.Type.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.TypedFeature != null && poco.TypedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "typedFeature", null, poco.TypedFeature.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -403,7 +428,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureTyping poco,
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -411,82 +436,68 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureTyping poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeature != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
             if (poco.Type != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.Type, "type", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.Type.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.Type, "type", elementOriginMap, currentFileUri);
+                }
             }
 
             if (poco.TypedFeature != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.TypedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.TypedFeature, "typedFeature", elementOriginMap, currentFileUri);
+                }
             }
 
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs
index c3330b93f..4d86f8e15 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureValueWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.FeatureValues;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FeatureValueWriter" /> is to write an instance of <see cref="IFeatureValue" />
@@ -72,17 +73,10 @@ public FeatureValueWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFacto
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureValue" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FeatureValue");
@@ -109,6 +103,14 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureWithValue != null && poco.featureWithValue.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureWithValue", poco.featureWithValue.Id.ToString());
+                }
+            }
+
             if (poco.IsDefault)
             {
                 xmlWriter.WriteAttributeString("isDefault", "true");
@@ -119,7 +121,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -129,7 +131,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 xmlWriter.WriteAttributeString("isInitial", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -137,7 +139,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -145,7 +147,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -153,7 +155,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -161,7 +163,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -169,7 +171,23 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -177,7 +195,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -185,11 +203,22 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.value != null && poco.value.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("value", poco.value.Id.ToString());
+                }
+            }
+
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -200,40 +229,35 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureWithValue != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureWithValue, "featureWithValue", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.membershipOwningNamespace != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureWithValue.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureWithValue, "featureWithValue", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -242,7 +266,7 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -250,56 +274,44 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -310,11 +322,11 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.value != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.value, "value", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.value, "value", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -328,18 +340,11 @@ public override void Write(XmlWriter xmlWriter, IFeatureValue poco, string eleme
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeatureValue" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FeatureValue");
@@ -366,6 +371,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureWithValue != null && poco.featureWithValue.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureWithValue", null, poco.featureWithValue.Id.ToString());
+                }
+            }
+
             if (poco.IsDefault)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isDefault", null, "true");
@@ -376,7 +389,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -386,7 +399,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isInitial", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -394,7 +407,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -402,7 +415,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -410,7 +423,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -418,7 +431,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -426,7 +439,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -434,7 +463,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -442,55 +471,61 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.value != null && poco.value.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "value", null, poco.value.Id.ToString());
+                }
+            }
+
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureWithValue != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureWithValue, "featureWithValue", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.membershipOwningNamespace != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureWithValue.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureWithValue, "featureWithValue", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -499,7 +534,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -507,71 +542,59 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeatureValue poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.value != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.value, "value", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.value, "value", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs
index a7edea580..3d267b4fc 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FeatureWriter.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FeatureWriter" /> is to write an instance of <see cref="IFeature" />
@@ -71,17 +72,10 @@ public FeatureWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory lo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeature" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFeature poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Feature");
@@ -93,6 +87,14 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -103,13 +105,32 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -120,7 +141,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -143,12 +164,12 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -171,9 +192,9 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -181,7 +202,15 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -189,7 +218,55 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +274,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -207,7 +284,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -218,15 +295,18 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -237,7 +317,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -248,7 +328,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -259,7 +339,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -270,15 +350,18 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -289,7 +372,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -300,15 +383,18 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -319,7 +405,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -330,7 +416,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -341,7 +427,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -352,7 +438,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -363,7 +449,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -374,18 +460,18 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -396,15 +482,18 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -415,67 +504,67 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -486,7 +575,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -497,99 +586,99 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -597,111 +686,99 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -712,7 +789,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -723,7 +800,7 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -744,18 +821,11 @@ public override void Write(XmlWriter xmlWriter, IFeature poco, string elementNam
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFeature" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Feature");
@@ -767,6 +837,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -777,13 +855,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -794,7 +891,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -817,12 +914,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -845,9 +942,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -855,7 +952,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -863,7 +968,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -871,7 +1024,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -881,389 +1034,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1271,139 +1436,127 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFeature poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs
index 62c73628b..4297a7c3d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowDefinitionWriter.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Flows;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FlowDefinitionWriter" /> is to write an instance of <see cref="IFlowDefinition" />
@@ -96,17 +97,10 @@ public FlowDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFlowDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FlowDefinition");
@@ -138,7 +132,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -151,7 +145,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -161,7 +155,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -179,7 +173,15 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -187,7 +189,31 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -195,7 +221,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -203,9 +229,17 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceType", poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
@@ -216,7 +250,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -227,7 +261,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -238,7 +272,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -249,7 +283,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -260,7 +294,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -271,7 +305,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowEnd != null)
                 {
@@ -282,7 +316,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -293,7 +327,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -304,7 +338,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -315,7 +349,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -326,7 +360,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -337,18 +371,18 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -359,15 +393,18 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -378,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -389,7 +426,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -400,7 +437,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -411,18 +448,18 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -433,7 +470,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -444,7 +481,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -455,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -466,26 +503,26 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -496,40 +533,40 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -540,7 +577,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -551,7 +588,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -562,18 +599,18 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -584,18 +621,18 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -606,18 +643,18 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -628,29 +665,29 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -661,7 +698,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -672,7 +709,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -683,7 +720,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -694,7 +731,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -709,7 +746,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -717,11 +754,11 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -732,7 +769,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -743,18 +780,18 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -765,18 +802,18 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -787,18 +824,18 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -809,7 +846,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -820,7 +857,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -831,7 +868,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -842,7 +879,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -853,41 +890,29 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -898,7 +923,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
@@ -909,15 +934,18 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -928,7 +956,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
@@ -939,7 +967,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -950,7 +978,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -961,7 +989,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -972,7 +1000,7 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -983,13 +1011,13 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1004,18 +1032,11 @@ public override void Write(XmlWriter xmlWriter, IFlowDefinition poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFlowDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FlowDefinition");
@@ -1047,7 +1068,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1060,7 +1081,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1070,7 +1091,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1088,7 +1109,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1096,7 +1125,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1104,7 +1157,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1112,504 +1165,515 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco,
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceType", null, poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "action", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowEnd != null)
                 {
                     foreach (var item in poco.flowEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "flowEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1618,7 +1682,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco,
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1626,279 +1690,270 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowDefinition poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs
index 3984e043f..98d23f712 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowEndWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Interactions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FlowEndWriter" /> is to write an instance of <see cref="IFlowEnd" />
@@ -72,17 +73,10 @@ public FlowEndWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory lo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFlowEnd" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FlowEnd");
@@ -94,6 +88,14 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -104,13 +106,32 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -121,7 +142,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,12 +165,12 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -172,9 +193,9 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -182,7 +203,15 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -190,7 +219,55 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -198,7 +275,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -208,7 +285,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -219,15 +296,18 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -238,7 +318,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -249,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -260,7 +340,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -271,15 +351,18 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -290,7 +373,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -301,15 +384,18 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -320,7 +406,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -331,7 +417,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -342,7 +428,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -353,7 +439,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -364,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -375,18 +461,18 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -397,15 +483,18 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -416,67 +505,67 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -487,7 +576,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -498,99 +587,99 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -598,111 +687,99 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -713,7 +790,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -724,7 +801,7 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -745,18 +822,11 @@ public override void Write(XmlWriter xmlWriter, IFlowEnd poco, string elementNam
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFlowEnd" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FlowEnd");
@@ -768,6 +838,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -778,13 +856,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -795,7 +892,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -818,12 +915,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -846,9 +943,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -856,7 +953,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -864,7 +969,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -872,7 +1025,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -882,389 +1035,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1272,139 +1437,127 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowEnd poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs
index ba4e45c77..4f7d999c8 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowUsageWriter.cs
@@ -70,6 +70,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Flows;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FlowUsageWriter" /> is to write an instance of <see cref="IFlowUsage" />
@@ -100,17 +101,10 @@ public FlowUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFlowUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FlowUsage");
@@ -122,6 +116,14 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -132,13 +134,48 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -149,7 +186,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -177,7 +214,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -187,7 +224,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -205,7 +242,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -218,9 +255,9 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -228,7 +265,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -236,7 +273,15 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -244,9 +289,84 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadFeature != null && poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("payloadFeature", poco.payloadFeature.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -254,7 +374,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -262,9 +382,33 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceOutputFeature != null && poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceOutputFeature", poco.sourceOutputFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetInputFeature != null && poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("targetInputFeature", poco.targetInputFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -275,7 +419,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -286,7 +430,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -297,23 +441,29 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -324,7 +474,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -335,7 +485,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -346,15 +496,18 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -365,7 +518,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -376,15 +529,18 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -395,7 +551,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowDefinition != null)
                 {
@@ -406,7 +562,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowEnd != null)
                 {
@@ -417,7 +573,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -428,15 +584,18 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -447,7 +606,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -458,7 +617,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -469,7 +628,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -480,18 +639,18 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -502,15 +661,18 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -521,7 +683,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -532,7 +694,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -543,7 +705,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -554,7 +716,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -565,7 +727,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -576,7 +738,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -587,18 +749,18 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -609,7 +771,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -620,7 +782,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -631,7 +793,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -642,7 +804,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -653,7 +815,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -664,7 +826,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -675,7 +837,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -686,7 +848,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -697,7 +859,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -708,7 +870,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -719,7 +881,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -730,7 +892,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -741,7 +903,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -752,7 +914,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -763,7 +925,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -774,7 +936,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -785,7 +947,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -796,7 +958,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -807,7 +969,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -818,7 +980,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -829,67 +991,67 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -900,7 +1062,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -911,99 +1073,99 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1011,7 +1173,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1019,132 +1181,121 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1155,15 +1306,18 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadType != null)
                 {
@@ -1174,7 +1328,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -1185,23 +1339,29 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceOutputFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -1212,15 +1372,18 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetInputFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1231,7 +1394,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1242,7 +1405,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1253,7 +1416,7 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1264,13 +1427,13 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1285,18 +1448,11 @@ public override void Write(XmlWriter xmlWriter, IFlowUsage poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFlowUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FlowUsage");
@@ -1308,6 +1464,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1318,13 +1482,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1335,7 +1534,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1363,7 +1562,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1373,7 +1572,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1391,7 +1590,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1404,9 +1603,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1414,7 +1613,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1422,7 +1621,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1430,9 +1637,84 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadFeature != null && poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "payloadFeature", null, poco.payloadFeature.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1440,7 +1722,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1448,748 +1730,790 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceOutputFeature != null && poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceOutputFeature", null, poco.sourceOutputFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetInputFeature != null && poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "targetInputFeature", null, poco.targetInputFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowDefinition != null)
                 {
                     foreach (var item in poco.flowDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "flowDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowEnd != null)
                 {
                     foreach (var item in poco.flowEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "flowEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2197,7 +2521,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -2205,258 +2529,259 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlowUsage poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadType != null)
                 {
                     foreach (var item in poco.payloadType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "payloadType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceOutputFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetInputFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs
index db6c20152..f83758cf9 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FlowWriter.cs
@@ -46,6 +46,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Interactions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FlowWriter" /> is to write an instance of <see cref="IFlow" />
@@ -76,17 +77,10 @@ public FlowWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory logge
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFlow" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Flow");
@@ -98,6 +92,14 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -108,13 +110,40 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -125,7 +154,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -153,12 +182,12 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -181,9 +210,9 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -191,7 +220,15 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -199,7 +236,63 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadFeature != null && poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("payloadFeature", poco.payloadFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -207,7 +300,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -215,9 +308,33 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceOutputFeature != null && poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceOutputFeature", poco.sourceOutputFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetInputFeature != null && poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("targetInputFeature", poco.targetInputFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -228,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -239,23 +356,29 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -266,7 +389,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -277,15 +400,18 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -296,7 +422,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -307,15 +433,18 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -326,7 +455,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowEnd != null)
                 {
@@ -337,7 +466,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -348,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -359,7 +488,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -370,7 +499,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -381,7 +510,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.interaction != null)
                 {
@@ -392,7 +521,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -403,18 +532,18 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -425,15 +554,18 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -444,67 +576,67 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -515,7 +647,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -526,99 +658,99 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -626,7 +758,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -634,116 +766,99 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -754,15 +869,18 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadType != null)
                 {
@@ -773,7 +891,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -784,23 +902,29 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceOutputFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -811,15 +935,18 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetInputFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -830,7 +957,7 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -851,18 +978,11 @@ public override void Write(XmlWriter xmlWriter, IFlow poco, string elementName,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFlow" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Flow");
@@ -874,6 +994,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -884,13 +1012,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -901,7 +1056,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -929,12 +1084,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -957,9 +1112,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -967,7 +1122,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -975,7 +1138,63 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadFeature != null && poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "payloadFeature", null, poco.payloadFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -983,7 +1202,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -991,410 +1210,449 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceOutputFeature != null && poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceOutputFeature", null, poco.sourceOutputFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetInputFeature != null && poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "targetInputFeature", null, poco.targetInputFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowEnd != null)
                 {
                     foreach (var item in poco.flowEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "flowEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.interaction != null)
                 {
                     foreach (var item in poco.interaction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "interaction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "interaction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1402,7 +1660,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1410,209 +1668,204 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFlow poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadType != null)
                 {
                     foreach (var item in poco.payloadType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "payloadType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceOutputFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetInputFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs
index 7030de5d0..a6c3ca649 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForLoopActionUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ForLoopActionUsageWriter" /> is to write an instance of <see cref="IForLoopActionUsage" />
@@ -98,17 +99,10 @@ public ForLoopActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogge
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IForLoopActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ForLoopActionUsage");
@@ -120,6 +114,22 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.bodyAction != null && poco.bodyAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("bodyAction", poco.bodyAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +140,40 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +184,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +207,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +217,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -198,7 +235,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -211,9 +248,9 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -221,7 +258,15 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.loopVariable != null && poco.loopVariable.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("loopVariable", poco.loopVariable.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -229,7 +274,15 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -237,9 +290,76 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -247,7 +367,15 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.seqArgument != null && poco.seqArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("seqArgument", poco.seqArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -257,7 +385,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -268,15 +396,18 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.bodyAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.bodyAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -287,15 +418,18 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -306,7 +440,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -317,7 +451,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -328,7 +462,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -339,15 +473,18 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -358,7 +495,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -369,15 +506,18 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -388,7 +528,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -399,15 +539,18 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -418,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -429,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -440,7 +583,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -451,26 +594,29 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.loopVariable != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.loopVariable, "loopVariable", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.loopVariable.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.loopVariable, "loopVariable", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -481,15 +627,18 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -500,7 +649,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -511,7 +660,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -522,7 +671,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -533,7 +682,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -544,7 +693,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -555,7 +704,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -566,18 +715,18 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -588,7 +737,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -599,7 +748,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -610,7 +759,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -621,7 +770,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -632,7 +781,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -643,7 +792,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -654,7 +803,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -665,7 +814,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -676,7 +825,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -687,7 +836,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -698,7 +847,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -709,7 +858,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -720,7 +869,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -731,7 +880,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -742,7 +891,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -753,7 +902,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -764,7 +913,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -775,7 +924,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -786,7 +935,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -797,7 +946,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -808,67 +957,67 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -879,7 +1028,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -890,99 +1039,99 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -990,127 +1139,121 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1121,15 +1264,18 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.seqArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.seqArgument, "seqArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.seqArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.seqArgument, "seqArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1140,7 +1286,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1151,7 +1297,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1162,7 +1308,7 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1173,13 +1319,13 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1194,18 +1340,11 @@ public override void Write(XmlWriter xmlWriter, IForLoopActionUsage poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IForLoopActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ForLoopActionUsage");
@@ -1217,6 +1356,22 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.bodyAction != null && poco.bodyAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "bodyAction", null, poco.bodyAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1227,13 +1382,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1244,7 +1426,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1267,7 +1449,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1277,7 +1459,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1295,7 +1477,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1308,9 +1490,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1318,7 +1500,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.loopVariable != null && poco.loopVariable.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "loopVariable", null, poco.loopVariable.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1326,7 +1516,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1334,9 +1532,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1344,7 +1609,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.seqArgument != null && poco.seqArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "seqArgument", null, poco.seqArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1354,732 +1627,753 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.bodyAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.bodyAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.loopVariable != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.loopVariable, "loopVariable", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.loopVariable.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.loopVariable, "loopVariable", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2087,196 +2381,193 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForLoopActionUsage p
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.seqArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.seqArgument, "seqArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.seqArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.seqArgument, "seqArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs
index fca8d0acb..9fab02c53 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ForkNodeWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ForkNodeWriter" /> is to write an instance of <see cref="IForkNode" />
@@ -97,17 +98,10 @@ public ForkNodeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory l
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IForkNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ForkNode");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,40 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +175,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +198,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -197,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -210,9 +239,9 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -220,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -228,7 +257,15 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -236,9 +273,76 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -246,7 +350,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -256,7 +360,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -267,7 +371,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -278,15 +382,18 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -297,7 +404,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -308,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -319,7 +426,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -330,15 +437,18 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -349,7 +459,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -360,15 +470,18 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -379,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -390,15 +503,18 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -409,7 +525,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -420,7 +536,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -431,7 +547,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -442,18 +558,18 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -464,15 +580,18 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -483,7 +602,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -494,7 +613,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -505,7 +624,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -516,7 +635,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -527,7 +646,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -538,7 +657,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -549,18 +668,18 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -571,7 +690,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -582,7 +701,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -593,7 +712,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -604,7 +723,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -615,7 +734,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -626,7 +745,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -637,7 +756,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -648,7 +767,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -659,7 +778,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -670,7 +789,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -681,7 +800,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -692,7 +811,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -703,7 +822,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -714,7 +833,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -725,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -736,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -747,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -758,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -769,7 +888,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -780,7 +899,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -791,67 +910,67 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -862,7 +981,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -873,99 +992,99 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -973,127 +1092,121 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1104,7 +1217,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1115,7 +1228,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1126,7 +1239,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1137,7 +1250,7 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1148,13 +1261,13 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1169,18 +1282,11 @@ public override void Write(XmlWriter xmlWriter, IForkNode poco, string elementNa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IForkNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ForkNode");
@@ -1192,6 +1298,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1202,13 +1316,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1219,7 +1360,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1242,7 +1383,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1252,7 +1393,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1270,7 +1411,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1283,9 +1424,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1293,7 +1434,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1301,7 +1442,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1309,9 +1458,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1319,7 +1535,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1329,716 +1545,731 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2046,188 +2277,182 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IForkNode poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs
index 333eba323..bffce5074 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FramedConcernMembershipWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Constraints;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FramedConcernMembershipWriter" /> is to write an instance of <see cref="IFramedConcernMembership" />
@@ -74,17 +75,10 @@ public FramedConcernMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, I
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFramedConcernMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:FramedConcernMembership");
@@ -116,12 +110,12 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -129,9 +123,12 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
                 }
             }
 
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            if (poco.Kind != RequirementConstraintKind.Requirement)
+            {
+                xmlWriter.WriteAttributeString("kind", poco.Kind.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -139,7 +136,15 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConcern != null && poco.ownedConcern.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConcern", poco.ownedConcern.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -147,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -155,7 +160,7 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -163,7 +168,23 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -171,7 +192,15 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referencedConcern != null && poco.referencedConcern.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("referencedConcern", poco.referencedConcern.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -179,11 +208,14 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -194,32 +226,32 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConcern, "ownedConcern", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConcern, "ownedConcern", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -228,7 +260,7 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -236,72 +268,55 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referencedConcern != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedConcern, "referencedConcern", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referencedConcern.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedConcern, "referencedConcern", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -322,18 +337,11 @@ public override void Write(XmlWriter xmlWriter, IFramedConcernMembership poco, s
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFramedConcernMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:FramedConcernMembership");
@@ -365,12 +373,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembers
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -378,9 +386,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembers
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+            if (poco.Kind != RequirementConstraintKind.Requirement)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -388,7 +399,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConcern != null && poco.ownedConcern.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConcern", null, poco.ownedConcern.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -396,7 +415,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -404,7 +423,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -412,7 +431,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -420,7 +455,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referencedConcern != null && poco.referencedConcern.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "referencedConcern", null, poco.referencedConcern.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -428,47 +471,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembers
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConcern, "ownedConcern", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConcern, "ownedConcern", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -477,7 +523,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembers
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -485,78 +531,61 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFramedConcernMembers
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referencedConcern != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referencedConcern, "referencedConcern", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referencedConcern.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.referencedConcern, "referencedConcern", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs
index d9ccbc048..44efab7a1 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/FunctionWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="FunctionWriter" /> is to write an instance of <see cref="IFunction" />
@@ -73,17 +74,10 @@ public FunctionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory l
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFunction" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IFunction poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IFunction poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Function");
@@ -115,7 +109,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -123,12 +117,12 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -149,7 +143,15 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -157,7 +159,31 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -165,7 +191,15 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -175,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -186,7 +220,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -197,7 +231,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -208,7 +242,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -219,7 +253,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -230,7 +264,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -241,7 +275,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -252,7 +286,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -263,7 +297,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -274,7 +308,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -285,7 +319,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -296,18 +330,18 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -318,15 +352,18 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -337,59 +374,59 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -400,7 +437,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -411,57 +448,57 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -470,73 +507,66 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -547,15 +577,18 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -566,7 +599,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -577,7 +610,7 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -598,18 +631,11 @@ public override void Write(XmlWriter xmlWriter, IFunction poco, string elementNa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IFunction" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Function");
@@ -641,7 +667,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -649,12 +675,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, strin
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -662,7 +688,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -675,7 +701,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -683,7 +717,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -691,7 +749,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -701,293 +767,296 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, strin
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -996,120 +1065,116 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IFunction poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs
index 2f68039ae..e9c85afcf 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IfActionUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="IfActionUsageWriter" /> is to write an instance of <see cref="IIfActionUsage" />
@@ -98,17 +99,10 @@ public IfActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFact
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IIfActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:IfActionUsage");
@@ -120,6 +114,14 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +132,56 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.elseAction != null && poco.elseAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("elseAction", poco.elseAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ifArgument != null && poco.ifArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ifArgument", poco.ifArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +192,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +215,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -198,7 +243,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -211,9 +256,9 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -221,7 +266,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -229,7 +274,15 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -237,9 +290,76 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -247,7 +367,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -255,9 +375,17 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.thenAction != null && poco.thenAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("thenAction", poco.thenAction.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -268,7 +396,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -279,15 +407,18 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -298,7 +429,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -309,7 +440,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -320,15 +451,18 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.elseAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.elseAction, "elseAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.elseAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.elseAction, "elseAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -339,15 +473,18 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -358,7 +495,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -369,15 +506,18 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -388,15 +528,18 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ifArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ifArgument, "ifArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.ifArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ifArgument, "ifArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -407,15 +550,18 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -426,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -437,7 +583,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -448,7 +594,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -459,18 +605,18 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -481,15 +627,18 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -500,7 +649,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -511,7 +660,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -522,7 +671,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -533,7 +682,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -544,7 +693,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -555,7 +704,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -566,18 +715,18 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -588,7 +737,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -599,7 +748,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -610,7 +759,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -621,7 +770,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -632,7 +781,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -643,7 +792,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -654,7 +803,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -665,7 +814,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -676,7 +825,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -687,7 +836,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -698,7 +847,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -709,7 +858,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -720,7 +869,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -731,7 +880,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -742,7 +891,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -753,7 +902,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -764,7 +913,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -775,7 +924,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -786,7 +935,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -797,7 +946,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -808,67 +957,67 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -879,7 +1028,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -890,99 +1039,99 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -990,127 +1139,121 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1121,7 +1264,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1132,15 +1275,18 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.thenAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.thenAction, "thenAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.thenAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.thenAction, "thenAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1151,7 +1297,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1162,7 +1308,7 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1173,13 +1319,13 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1194,18 +1340,11 @@ public override void Write(XmlWriter xmlWriter, IIfActionUsage poco, string elem
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IIfActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:IfActionUsage");
@@ -1217,6 +1356,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1227,13 +1374,56 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.elseAction != null && poco.elseAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "elseAction", null, poco.elseAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ifArgument != null && poco.ifArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ifArgument", null, poco.ifArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1244,7 +1434,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1267,7 +1457,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1277,7 +1467,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1295,7 +1485,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1308,9 +1498,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1318,7 +1508,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1326,7 +1516,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1334,9 +1532,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1344,7 +1609,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1352,734 +1617,763 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.thenAction != null && poco.thenAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "thenAction", null, poco.thenAction.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.elseAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.elseAction, "elseAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.elseAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.elseAction, "elseAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ifArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ifArgument, "ifArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.ifArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ifArgument, "ifArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2087,196 +2381,193 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIfActionUsage poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.thenAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.thenAction, "thenAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.thenAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.thenAction, "thenAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs
index f5230a939..76f9ba992 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IncludeUseCaseUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="IncludeUseCaseUsageWriter" /> is to write an instance of <see cref="IIncludeUseCaseUsage" />
@@ -98,17 +99,10 @@ public IncludeUseCaseUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IIncludeUseCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:IncludeUseCaseUsage");
@@ -120,6 +114,14 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +132,40 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +176,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +199,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -188,7 +217,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -206,11 +235,11 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    xmlWriter.WriteAttributeString("isReference", "true");
+                    xmlWriter.WriteAttributeString("isReference", "false");
                 }
             }
 
@@ -219,9 +248,9 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -229,7 +258,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -237,7 +266,15 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -245,9 +282,84 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("objectiveRequirement", poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -255,7 +367,15 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -263,9 +383,33 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.useCaseDefinition != null && poco.useCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("useCaseDefinition", poco.useCaseDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.useCaseIncluded != null && poco.useCaseIncluded.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("useCaseIncluded", poco.useCaseIncluded.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -276,7 +420,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -287,7 +431,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -298,15 +442,18 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -317,7 +464,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -328,7 +475,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -339,7 +486,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -350,15 +497,18 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -369,7 +519,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -380,15 +530,18 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -399,7 +552,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -410,7 +563,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.includedUseCase != null)
                 {
@@ -421,15 +574,18 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -440,7 +596,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -451,7 +607,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -462,7 +618,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -473,18 +629,18 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -495,15 +651,18 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -514,7 +673,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -525,7 +684,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -536,7 +695,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -547,7 +706,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -558,7 +717,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -569,7 +728,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -580,18 +739,18 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -602,7 +761,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -613,7 +772,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -624,7 +783,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -635,7 +794,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -646,7 +805,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -657,7 +816,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -668,7 +827,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -679,7 +838,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -690,7 +849,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -701,7 +860,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -712,7 +871,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -723,7 +882,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -734,7 +893,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -745,7 +904,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -756,7 +915,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -767,7 +926,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -778,7 +937,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -789,7 +948,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -800,15 +959,18 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -819,7 +981,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -830,67 +992,67 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -901,7 +1063,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -912,99 +1074,99 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1012,127 +1174,121 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1143,23 +1299,29 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1170,7 +1332,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1181,7 +1343,7 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1192,23 +1354,29 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.useCaseDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.useCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.useCaseIncluded != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseIncluded, "useCaseIncluded", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.useCaseIncluded.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseIncluded, "useCaseIncluded", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1219,13 +1387,13 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1240,18 +1408,11 @@ public override void Write(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, strin
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IIncludeUseCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:IncludeUseCaseUsage");
@@ -1263,6 +1424,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1273,13 +1442,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1290,7 +1486,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1313,7 +1509,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1323,7 +1519,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1331,7 +1527,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1349,11 +1545,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "false");
                 }
             }
 
@@ -1362,9 +1558,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1372,7 +1568,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1380,7 +1576,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1388,9 +1592,84 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "objectiveRequirement", null, poco.objectiveRequirement.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1398,7 +1677,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1406,748 +1693,790 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.useCaseDefinition != null && poco.useCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "useCaseDefinition", null, poco.useCaseDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.useCaseIncluded != null && poco.useCaseIncluded.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "useCaseIncluded", null, poco.useCaseIncluded.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.includedUseCase != null)
                 {
                     foreach (var item in poco.includedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "includedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2155,220 +2484,226 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIncludeUseCaseUsage
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.useCaseDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.useCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.useCaseIncluded != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.useCaseIncluded, "useCaseIncluded", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.useCaseIncluded.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.useCaseIncluded, "useCaseIncluded", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs
index 8c9e566bf..561047666 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IndexExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="IndexExpressionWriter" /> is to write an instance of <see cref="IIndexExpression" />
@@ -74,17 +75,10 @@ public IndexExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IIndexExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:IndexExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,48 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("instantiatedType", poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +160,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +183,12 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +196,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +219,9 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +229,15 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,12 +245,63 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            if (poco.Operator != "#")
+            {
+                if (!string.IsNullOrWhiteSpace(poco.Operator))
+                {
+                    xmlWriter.WriteAttributeString("operator", poco.Operator);
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
-                xmlWriter.WriteAttributeString("operator", poco.Operator);
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -213,7 +309,15 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -223,7 +327,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
@@ -234,7 +338,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -245,15 +349,18 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -264,7 +371,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -275,7 +382,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -286,15 +393,18 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -305,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -316,15 +426,18 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -335,15 +448,18 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -354,7 +470,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -365,7 +481,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -376,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -387,15 +503,18 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -406,18 +525,18 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -428,15 +547,18 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -447,67 +569,67 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -518,7 +640,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -529,99 +651,99 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -629,111 +751,99 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -744,15 +854,18 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -763,7 +876,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -774,7 +887,7 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -795,18 +908,11 @@ public override void Write(XmlWriter xmlWriter, IIndexExpression poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IIndexExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:IndexExpression");
@@ -818,6 +924,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -828,13 +942,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "instantiatedType", null, poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -845,7 +994,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -868,12 +1017,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -881,7 +1030,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -904,9 +1053,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -914,7 +1063,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -922,12 +1079,63 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
                 }
             }
 
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            if (poco.Operator != "#")
+            {
+                if (!string.IsNullOrWhiteSpace(poco.Operator))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -935,7 +1143,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -945,405 +1161,423 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1351,158 +1585,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIndexExpression poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs
index fac313ed9..777622674 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InteractionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Interactions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="InteractionWriter" /> is to write an instance of <see cref="IInteraction" />
@@ -74,17 +75,10 @@ public InteractionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactor
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IInteraction" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IInteraction poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IInteraction poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Interaction");
@@ -116,7 +110,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -129,12 +123,12 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -147,7 +141,15 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -155,7 +157,31 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -163,7 +189,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -171,9 +197,17 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceType", poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.associationEnd != null)
                 {
@@ -184,7 +218,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -195,7 +229,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -206,7 +240,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -217,7 +251,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -228,7 +262,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -239,7 +273,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -250,7 +284,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -261,7 +295,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -272,7 +306,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -283,18 +317,18 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -305,15 +339,18 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -324,59 +361,59 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -387,7 +424,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -398,57 +435,57 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -457,7 +494,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -465,78 +502,66 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -547,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
@@ -558,15 +583,18 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -577,7 +605,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
@@ -588,7 +616,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -599,7 +627,7 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -620,18 +648,11 @@ public override void Write(XmlWriter xmlWriter, IInteraction poco, string elemen
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IInteraction" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Interaction");
@@ -663,7 +684,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -676,12 +697,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -694,7 +715,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, st
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -702,7 +731,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -710,7 +763,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, st
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -718,284 +771,295 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, st
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceType", null, poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.associationEnd != null)
                 {
                     foreach (var item in poco.associationEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "associationEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "associationEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1004,7 +1068,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, st
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1012,147 +1076,138 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInteraction poco, st
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs
index 8c3c42a1f..10bf91e58 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Interfaces;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="InterfaceDefinitionWriter" /> is to write an instance of <see cref="IInterfaceDefinition" />
@@ -94,17 +95,10 @@ public InterfaceDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IInterfaceDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:InterfaceDefinition");
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -149,7 +143,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -159,7 +153,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -167,9 +161,9 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (poco.IsSufficient)
+            if (!poco.IsSufficient)
             {
-                xmlWriter.WriteAttributeString("isSufficient", "true");
+                xmlWriter.WriteAttributeString("isSufficient", "false");
             }
 
             if (poco.IsVariation)
@@ -177,7 +171,15 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -185,7 +187,31 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -193,7 +219,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -201,9 +227,17 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceType", poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -214,7 +248,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -225,7 +259,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -236,7 +270,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -247,7 +281,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -258,7 +292,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -269,7 +303,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -280,7 +314,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -291,7 +325,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -302,7 +336,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -313,7 +347,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.interfaceEnd != null)
                 {
@@ -324,7 +358,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -335,18 +369,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -357,15 +391,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -376,7 +413,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -387,7 +424,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -398,7 +435,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -409,18 +446,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -431,7 +468,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -442,7 +479,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -453,7 +490,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -464,26 +501,26 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -494,40 +531,40 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -538,7 +575,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -549,7 +586,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -560,18 +597,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -582,18 +619,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -604,18 +641,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -626,29 +663,29 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -659,7 +696,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -670,7 +707,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -681,7 +718,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -692,7 +729,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -707,7 +744,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -715,11 +752,11 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -730,7 +767,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -741,18 +778,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -763,18 +800,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -785,18 +822,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -807,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -818,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -829,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -840,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -851,41 +888,29 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
@@ -896,15 +921,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
@@ -915,7 +943,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -926,7 +954,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -937,7 +965,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -948,7 +976,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -959,13 +987,13 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -980,18 +1008,11 @@ public override void Write(XmlWriter xmlWriter, IInterfaceDefinition poco, strin
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IInterfaceDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:InterfaceDefinition");
@@ -1023,7 +1044,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1036,7 +1057,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1046,7 +1067,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1054,9 +1075,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition
                 }
             }
 
-            if (poco.IsSufficient)
+            if (!poco.IsSufficient)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1064,7 +1085,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1072,7 +1101,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1080,7 +1133,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1088,504 +1141,515 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceType != null && poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceType", null, poco.sourceType.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.interfaceEnd != null)
                 {
                     foreach (var item in poco.interfaceEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "interfaceEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "interfaceEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1594,7 +1658,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1602,257 +1666,248 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceDefinition
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedType != null)
                 {
                     foreach (var item in poco.relatedType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceType, "sourceType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetType != null)
                 {
                     foreach (var item in poco.targetType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs
index f82d8c4b4..a8d5913bf 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InterfaceUsageWriter.cs
@@ -69,6 +69,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Interfaces;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="InterfaceUsageWriter" /> is to write an instance of <see cref="IInterfaceUsage" />
@@ -99,17 +100,10 @@ public InterfaceUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IInterfaceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:InterfaceUsage");
@@ -121,6 +115,14 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -131,13 +133,48 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -148,7 +185,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -176,7 +213,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -186,7 +223,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -204,7 +241,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -217,9 +254,9 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -227,7 +264,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -235,7 +272,15 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -243,9 +288,76 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -253,7 +365,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -261,9 +373,17 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -274,7 +394,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -285,23 +405,29 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -312,7 +438,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -323,7 +449,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -334,7 +460,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -345,15 +471,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -364,7 +493,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -375,15 +504,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -394,7 +526,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -405,15 +537,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -424,7 +559,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -435,7 +570,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -446,7 +581,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.interfaceDefinition != null)
                 {
@@ -457,7 +592,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -468,7 +603,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
@@ -479,18 +614,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -501,15 +636,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -520,7 +658,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -531,7 +669,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -542,7 +680,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -553,7 +691,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -564,7 +702,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -575,7 +713,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -586,18 +724,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -608,7 +746,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -619,7 +757,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -630,7 +768,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -641,7 +779,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -652,7 +790,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -663,7 +801,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -674,7 +812,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -685,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -696,7 +834,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -707,7 +845,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -718,7 +856,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -729,7 +867,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -740,7 +878,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -751,7 +889,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -762,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -773,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -784,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -795,7 +933,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -806,7 +944,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -817,7 +955,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -828,67 +966,67 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -899,7 +1037,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -910,99 +1048,99 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1010,7 +1148,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1018,132 +1156,121 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.partDefinition != null)
                 {
@@ -1154,7 +1281,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -1165,15 +1292,18 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -1184,7 +1314,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1195,7 +1325,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1206,7 +1336,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1217,7 +1347,7 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1228,13 +1358,13 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1249,18 +1379,11 @@ public override void Write(XmlWriter xmlWriter, IInterfaceUsage poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IInterfaceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:InterfaceUsage");
@@ -1272,6 +1395,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1282,13 +1413,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1299,7 +1465,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1327,7 +1493,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1337,7 +1503,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1355,7 +1521,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1368,9 +1534,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1378,7 +1544,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1386,7 +1552,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1394,9 +1568,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1404,7 +1645,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1412,748 +1653,774 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.interfaceDefinition != null)
                 {
                     foreach (var item in poco.interfaceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "interfaceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "interfaceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2161,7 +2428,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -2169,223 +2436,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInterfaceUsage poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.partDefinition != null)
                 {
                     foreach (var item in poco.partDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "partDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs
index edced38ce..520de01ae 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/IntersectingWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="IntersectingWriter" /> is to write an instance of <see cref="IIntersecting" />
@@ -69,17 +70,10 @@ public IntersectingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFacto
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IIntersecting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IIntersecting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IIntersecting poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Intersecting");
@@ -106,17 +100,22 @@ public override void Write(XmlWriter xmlWriter, IIntersecting poco, string eleme
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.IntersectingType != null && poco.IntersectingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("intersectingType", poco.IntersectingType.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +123,7 @@ public override void Write(XmlWriter xmlWriter, IIntersecting poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -132,7 +131,23 @@ public override void Write(XmlWriter xmlWriter, IIntersecting poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -140,7 +155,7 @@ public override void Write(XmlWriter xmlWriter, IIntersecting poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -150,7 +165,7 @@ public override void Write(XmlWriter xmlWriter, IIntersecting poco, string eleme
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -163,27 +178,30 @@ public override void Write(XmlWriter xmlWriter, IIntersecting poco, string eleme
 
             if (poco.IntersectingType != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.IntersectingType, "intersectingType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.IntersectingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.IntersectingType, "intersectingType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -192,7 +210,7 @@ public override void Write(XmlWriter xmlWriter, IIntersecting poco, string eleme
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -200,56 +218,44 @@ public override void Write(XmlWriter xmlWriter, IIntersecting poco, string eleme
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -260,14 +266,6 @@ public override void Write(XmlWriter xmlWriter, IIntersecting poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.typeIntersected != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeIntersected, "typeIntersected", elementOriginMap, currentFileUri);
-                }
-            }
-
 
             xmlWriter.WriteEndElement();
         }
@@ -278,18 +276,11 @@ public override void Write(XmlWriter xmlWriter, IIntersecting poco, string eleme
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IIntersecting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IIntersecting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IIntersecting poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Intersecting");
@@ -316,17 +307,22 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIntersecting poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.IntersectingType != null && poco.IntersectingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "intersectingType", null, poco.IntersectingType.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -334,7 +330,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIntersecting poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -342,7 +338,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIntersecting poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -350,7 +362,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIntersecting poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -360,40 +372,43 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIntersecting poco, s
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
             if (poco.IntersectingType != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.IntersectingType, "intersectingType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.IntersectingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.IntersectingType, "intersectingType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -402,7 +417,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIntersecting poco, s
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -410,74 +425,54 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IIntersecting poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.typeIntersected != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.typeIntersected, "typeIntersected", elementOriginMap, currentFileUri);
-                }
-            }
-
 
             await xmlWriter.WriteEndElementAsync();
         }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs
index 70c78f5c3..5af1646e2 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvariantWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="InvariantWriter" /> is to write an instance of <see cref="IInvariant" />
@@ -73,17 +74,10 @@ public InvariantWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IInvariant" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Invariant");
@@ -95,6 +89,14 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -105,13 +107,32 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -122,7 +143,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -145,12 +166,12 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -158,7 +179,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -186,9 +207,9 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -196,7 +217,15 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -204,7 +233,63 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.predicate != null && poco.predicate.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("predicate", poco.predicate.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -212,7 +297,15 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -222,7 +315,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -233,15 +326,18 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -252,7 +348,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -263,7 +359,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -274,15 +370,18 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -293,7 +392,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -304,15 +403,18 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -323,7 +425,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -334,7 +436,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -345,7 +447,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -356,7 +458,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -367,7 +469,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -378,18 +480,18 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -400,15 +502,18 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -419,67 +524,67 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -490,7 +595,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -501,99 +606,99 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -601,111 +706,99 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -716,23 +809,29 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.predicate != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.predicate.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -743,7 +842,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -754,7 +853,7 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -775,18 +874,11 @@ public override void Write(XmlWriter xmlWriter, IInvariant poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IInvariant" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Invariant");
@@ -798,6 +890,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -808,13 +908,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -825,7 +944,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -848,12 +967,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -861,7 +980,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -889,9 +1008,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -899,7 +1018,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -907,7 +1034,63 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.predicate != null && poco.predicate.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "predicate", null, poco.predicate.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -915,7 +1098,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -925,378 +1116,390 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1304,166 +1507,160 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvariant poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.predicate != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.predicate.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.predicate, "predicate", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs
index d3aa25fb3..21e91e408 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/InvocationExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="InvocationExpressionWriter" /> is to write an instance of <see cref="IInvocationExpression" />
@@ -74,17 +75,10 @@ public InvocationExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IInvocationExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:InvocationExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,48 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("instantiatedType", poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +160,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +183,12 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +196,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +219,9 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +229,15 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +245,55 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +301,15 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -218,7 +319,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
@@ -229,7 +330,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -240,15 +341,18 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -259,7 +363,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -270,7 +374,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -281,15 +385,18 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -300,7 +407,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -311,15 +418,18 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -330,15 +440,18 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -349,7 +462,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -360,7 +473,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -371,7 +484,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -382,15 +495,18 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -401,18 +517,18 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -423,15 +539,18 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -442,67 +561,67 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -513,7 +632,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -524,99 +643,99 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -624,111 +743,99 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -739,15 +846,18 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -758,7 +868,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -769,7 +879,7 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -790,18 +900,11 @@ public override void Write(XmlWriter xmlWriter, IInvocationExpression poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IInvocationExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:InvocationExpression");
@@ -813,6 +916,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -823,13 +934,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "instantiatedType", null, poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -840,7 +986,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -863,12 +1009,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -876,7 +1022,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -899,9 +1045,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -909,7 +1055,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -917,7 +1071,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -925,7 +1127,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -935,405 +1145,423 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1341,158 +1569,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IInvocationExpression
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs
index c30f52a55..1747dc6d0 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Items;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ItemDefinitionWriter" /> is to write an instance of <see cref="IItemDefinition" />
@@ -94,17 +95,10 @@ public ItemDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IItemDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ItemDefinition");
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,7 +138,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -154,7 +148,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -172,7 +166,15 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -180,7 +182,31 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -188,7 +214,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -198,7 +224,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -209,7 +235,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -220,7 +246,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -231,7 +257,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -242,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -253,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -264,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -275,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -286,7 +312,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -297,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -308,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -319,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -330,18 +356,18 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -352,15 +378,18 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -371,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -382,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -393,7 +422,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -404,18 +433,18 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -426,7 +455,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -437,7 +466,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -448,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -459,26 +488,26 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -489,40 +518,40 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -533,7 +562,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -544,7 +573,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -555,18 +584,18 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -577,18 +606,18 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -599,18 +628,18 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -621,29 +650,29 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -654,7 +683,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -665,7 +694,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -676,7 +705,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -687,7 +716,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -702,11 +731,11 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -717,7 +746,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -728,18 +757,18 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -750,18 +779,18 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -772,18 +801,18 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -794,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -805,7 +834,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -816,7 +845,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -827,7 +856,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -838,36 +867,29 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -878,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -889,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -900,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -911,13 +933,13 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -932,18 +954,11 @@ public override void Write(XmlWriter xmlWriter, IItemDefinition poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IItemDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ItemDefinition");
@@ -975,7 +990,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -983,7 +998,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco,
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -993,7 +1008,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1011,7 +1026,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1019,7 +1042,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1027,7 +1074,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1037,502 +1084,505 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1541,222 +1591,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemDefinition poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs
index 7c91f8170..2be0f2f54 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ItemUsageWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Items;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ItemUsageWriter" /> is to write an instance of <see cref="IItemUsage" />
@@ -97,17 +98,10 @@ public ItemUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IItemUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ItemUsage");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,40 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +175,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +198,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -197,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -210,9 +239,9 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -220,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -228,7 +257,15 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -236,9 +273,76 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -246,7 +350,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -256,7 +360,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -267,15 +371,18 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -286,7 +393,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -297,7 +404,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -308,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -319,7 +426,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -330,15 +437,18 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -349,7 +459,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -360,15 +470,18 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -379,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -390,15 +503,18 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -409,7 +525,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -420,7 +536,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -431,7 +547,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -442,7 +558,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
@@ -453,18 +569,18 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -475,15 +591,18 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -494,7 +613,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -505,7 +624,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -516,7 +635,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -527,7 +646,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -538,7 +657,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -549,7 +668,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -560,18 +679,18 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -582,7 +701,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -593,7 +712,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -604,7 +723,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -615,7 +734,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -626,7 +745,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -637,7 +756,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -648,7 +767,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -659,7 +778,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -670,7 +789,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -681,7 +800,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -692,7 +811,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -703,7 +822,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -714,7 +833,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -725,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -736,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -747,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -758,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -769,7 +888,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -780,7 +899,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -791,7 +910,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -802,67 +921,67 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -873,7 +992,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -884,99 +1003,99 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -984,127 +1103,121 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1115,7 +1228,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1126,7 +1239,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1137,7 +1250,7 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1148,13 +1261,13 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1169,18 +1282,11 @@ public override void Write(XmlWriter xmlWriter, IItemUsage poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IItemUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ItemUsage");
@@ -1192,6 +1298,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1202,13 +1316,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1219,7 +1360,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1242,7 +1383,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1252,7 +1393,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1270,7 +1411,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1283,9 +1424,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1293,7 +1434,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1301,7 +1442,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1309,9 +1458,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1319,7 +1535,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1329,727 +1545,742 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2057,177 +2288,171 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IItemUsage poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs
index 3688f72c8..80054946c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/JoinNodeWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="JoinNodeWriter" /> is to write an instance of <see cref="IJoinNode" />
@@ -97,17 +98,10 @@ public JoinNodeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory l
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IJoinNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:JoinNode");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,40 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +175,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +198,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -197,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -210,9 +239,9 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -220,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -228,7 +257,15 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -236,9 +273,76 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -246,7 +350,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -256,7 +360,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -267,7 +371,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -278,15 +382,18 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -297,7 +404,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -308,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -319,7 +426,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -330,15 +437,18 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -349,7 +459,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -360,15 +470,18 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -379,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -390,15 +503,18 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -409,7 +525,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -420,7 +536,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -431,7 +547,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -442,18 +558,18 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -464,15 +580,18 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -483,7 +602,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -494,7 +613,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -505,7 +624,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -516,7 +635,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -527,7 +646,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -538,7 +657,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -549,18 +668,18 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -571,7 +690,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -582,7 +701,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -593,7 +712,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -604,7 +723,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -615,7 +734,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -626,7 +745,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -637,7 +756,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -648,7 +767,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -659,7 +778,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -670,7 +789,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -681,7 +800,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -692,7 +811,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -703,7 +822,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -714,7 +833,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -725,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -736,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -747,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -758,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -769,7 +888,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -780,7 +899,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -791,67 +910,67 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -862,7 +981,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -873,99 +992,99 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -973,127 +1092,121 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1104,7 +1217,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1115,7 +1228,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1126,7 +1239,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1137,7 +1250,7 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1148,13 +1261,13 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1169,18 +1282,11 @@ public override void Write(XmlWriter xmlWriter, IJoinNode poco, string elementNa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IJoinNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:JoinNode");
@@ -1192,6 +1298,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1202,13 +1316,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1219,7 +1360,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1242,7 +1383,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1252,7 +1393,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1270,7 +1411,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1283,9 +1424,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1293,7 +1434,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1301,7 +1442,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1309,9 +1458,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1319,7 +1535,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1329,716 +1545,731 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2046,188 +2277,182 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IJoinNode poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs
index 79f995e1c..e97ab4e72 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LibraryPackageWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Packages;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="LibraryPackageWriter" /> is to write an instance of <see cref="ILibraryPackage" />
@@ -70,17 +71,10 @@ public LibraryPackageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILibraryPackage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LibraryPackage");
@@ -107,12 +101,12 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -125,7 +119,7 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
                 xmlWriter.WriteAttributeString("isStandard", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -133,7 +127,23 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -141,7 +151,7 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -151,7 +161,7 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -162,7 +172,7 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.filterCondition != null)
                 {
@@ -173,7 +183,7 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -184,18 +194,18 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -206,57 +216,57 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -265,40 +275,33 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -319,18 +322,11 @@ public override void Write(XmlWriter xmlWriter, ILibraryPackage poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILibraryPackage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ILibraryPackage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILibraryPackage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LibraryPackage");
@@ -357,12 +353,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILibraryPackage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -375,7 +371,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILibraryPackage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isStandard", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -383,7 +379,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILibraryPackage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -391,7 +403,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILibraryPackage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -401,112 +413,112 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILibraryPackage poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.filterCondition != null)
                 {
                     foreach (var item in poco.filterCondition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "filterCondition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "filterCondition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -515,46 +527,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILibraryPackage poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs
index f72d75cb3..bf4f187d3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralBooleanWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="LiteralBooleanWriter" /> is to write an instance of <see cref="ILiteralBoolean" />
@@ -74,17 +75,10 @@ public LiteralBooleanWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralBoolean" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralBoolean");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,40 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +175,12 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +188,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +211,9 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +221,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +237,55 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +293,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -223,7 +316,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -234,15 +327,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -253,7 +349,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -264,7 +360,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -275,15 +371,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -294,7 +393,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -305,15 +404,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -324,15 +426,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -343,7 +448,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -354,7 +459,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -365,7 +470,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -376,7 +481,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -387,18 +492,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -409,15 +514,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -428,67 +536,67 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -499,7 +607,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -510,99 +618,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -610,111 +718,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -725,15 +821,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -744,7 +843,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -755,7 +854,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -776,18 +875,11 @@ public override void Write(XmlWriter xmlWriter, ILiteralBoolean poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralBoolean" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralBoolean");
@@ -799,6 +891,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -809,13 +909,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -826,7 +953,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -849,12 +976,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -862,7 +989,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -885,9 +1012,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -895,7 +1022,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -903,7 +1038,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -911,7 +1094,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -926,386 +1117,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1313,158 +1519,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralBoolean poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs
index 3a8f7edec..98ae34812 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="LiteralExpressionWriter" /> is to write an instance of <see cref="ILiteralExpression" />
@@ -74,17 +75,10 @@ public LiteralExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,40 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +175,12 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +188,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +211,9 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +221,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +237,55 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +293,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -218,7 +311,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -229,15 +322,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -248,7 +344,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -259,7 +355,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -270,15 +366,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -289,7 +388,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -300,15 +399,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -319,15 +421,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -338,7 +443,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -349,7 +454,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -360,7 +465,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -371,7 +476,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -382,18 +487,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -404,15 +509,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -423,67 +531,67 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -494,7 +602,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -505,99 +613,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -605,111 +713,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -720,15 +816,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -739,7 +838,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -750,7 +849,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -771,18 +870,11 @@ public override void Write(XmlWriter xmlWriter, ILiteralExpression poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralExpression");
@@ -794,6 +886,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -804,13 +904,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -821,7 +948,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -844,12 +971,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -857,7 +984,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -880,9 +1007,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -890,7 +1017,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -898,7 +1033,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -906,7 +1089,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -916,386 +1107,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1303,158 +1509,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralExpression po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs
index c95db689d..2b558201f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralInfinityWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="LiteralInfinityWriter" /> is to write an instance of <see cref="ILiteralInfinity" />
@@ -74,17 +75,10 @@ public LiteralInfinityWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralInfinity" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralInfinity");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,40 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +175,12 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +188,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +211,9 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +221,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +237,55 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +293,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -218,7 +311,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -229,15 +322,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -248,7 +344,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -259,7 +355,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -270,15 +366,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -289,7 +388,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -300,15 +399,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -319,15 +421,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -338,7 +443,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -349,7 +454,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -360,7 +465,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -371,7 +476,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -382,18 +487,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -404,15 +509,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -423,67 +531,67 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -494,7 +602,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -505,99 +613,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -605,111 +713,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -720,15 +816,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -739,7 +838,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -750,7 +849,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -771,18 +870,11 @@ public override void Write(XmlWriter xmlWriter, ILiteralInfinity poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralInfinity" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralInfinity");
@@ -794,6 +886,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -804,13 +904,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -821,7 +948,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -844,12 +971,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -857,7 +984,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -880,9 +1007,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -890,7 +1017,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -898,7 +1033,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -906,7 +1089,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -916,386 +1107,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1303,158 +1509,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInfinity poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs
index ce9e83ec4..f6abcf1c5 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralIntegerWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="LiteralIntegerWriter" /> is to write an instance of <see cref="ILiteralInteger" />
@@ -74,17 +75,10 @@ public LiteralIntegerWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralInteger" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralInteger");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,40 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +175,12 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +188,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +211,9 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +221,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +237,55 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +293,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -220,7 +313,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -231,15 +324,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -250,7 +346,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -261,7 +357,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -272,15 +368,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -291,7 +390,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -302,15 +401,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -321,15 +423,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -340,7 +445,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -351,7 +456,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -362,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -373,7 +478,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -384,18 +489,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -406,15 +511,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -425,67 +533,67 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -496,7 +604,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -507,99 +615,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -607,111 +715,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -722,15 +818,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -741,7 +840,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -752,7 +851,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -773,18 +872,11 @@ public override void Write(XmlWriter xmlWriter, ILiteralInteger poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralInteger" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralInteger");
@@ -796,6 +888,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -806,13 +906,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -823,7 +950,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -846,12 +973,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -859,7 +986,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -882,9 +1009,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -892,7 +1019,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -900,7 +1035,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -908,7 +1091,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -920,386 +1111,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1307,158 +1513,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralInteger poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs
index d774cc151..00cfe9664 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralRationalWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="LiteralRationalWriter" /> is to write an instance of <see cref="ILiteralRational" />
@@ -74,17 +75,10 @@ public LiteralRationalWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralRational" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralRational");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,40 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +175,12 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +188,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +211,9 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +221,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +237,55 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +293,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -220,7 +313,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -231,15 +324,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -250,7 +346,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -261,7 +357,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -272,15 +368,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -291,7 +390,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -302,15 +401,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -321,15 +423,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -340,7 +445,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -351,7 +456,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -362,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -373,7 +478,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -384,18 +489,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -406,15 +511,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -425,67 +533,67 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -496,7 +604,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -507,99 +615,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -607,111 +715,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -722,15 +818,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -741,7 +840,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -752,7 +851,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -773,18 +872,11 @@ public override void Write(XmlWriter xmlWriter, ILiteralRational poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralRational" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralRational");
@@ -796,6 +888,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -806,13 +906,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -823,7 +950,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -846,12 +973,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -859,7 +986,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -882,9 +1009,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -892,7 +1019,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -900,7 +1035,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -908,7 +1091,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -920,386 +1111,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1307,158 +1513,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralRational poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs
index bec6b04fd..4e0b90af7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/LiteralStringWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="LiteralStringWriter" /> is to write an instance of <see cref="ILiteralString" />
@@ -74,17 +75,10 @@ public LiteralStringWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFact
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralString" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:LiteralString");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,40 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +175,12 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +188,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +211,9 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +221,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +237,55 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +293,15 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -223,7 +316,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -234,15 +327,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -253,7 +349,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -264,7 +360,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -275,15 +371,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -294,7 +393,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -305,15 +404,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -324,15 +426,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -343,7 +448,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -354,7 +459,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -365,7 +470,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -376,7 +481,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -387,18 +492,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -409,15 +514,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -428,67 +536,67 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -499,7 +607,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -510,99 +618,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -610,111 +718,99 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -725,15 +821,18 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -744,7 +843,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -755,7 +854,7 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -776,18 +875,11 @@ public override void Write(XmlWriter xmlWriter, ILiteralString poco, string elem
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ILiteralString" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:LiteralString");
@@ -799,6 +891,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -809,13 +909,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -826,7 +953,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -849,12 +976,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -862,7 +989,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -885,9 +1012,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -895,7 +1022,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -903,7 +1038,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -911,7 +1094,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -926,386 +1117,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1313,158 +1519,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ILiteralString poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs
index 760366253..6bf021190 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipExposeWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MembershipExposeWriter" /> is to write an instance of <see cref="IMembershipExpose" />
@@ -70,17 +71,10 @@ public MembershipExposeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMembershipExpose" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MembershipExpose");
@@ -107,22 +101,35 @@ public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string e
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.importedElement != null && poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("importedElement", poco.importedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.ImportedMembership != null && poco.ImportedMembership.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("importedMembership", poco.ImportedMembership.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (poco.IsImportAll)
+            if (!poco.IsImportAll)
             {
-                xmlWriter.WriteAttributeString("isImportAll", "true");
+                xmlWriter.WriteAttributeString("isImportAll", "false");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -135,7 +142,7 @@ public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string e
                 xmlWriter.WriteAttributeString("isRecursive", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -143,7 +150,23 @@ public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -151,7 +174,7 @@ public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -159,11 +182,14 @@ public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string e
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Protected)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -174,45 +200,43 @@ public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedElement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
             if (poco.ImportedMembership != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.importOwningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ImportedMembership.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -221,7 +245,7 @@ public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string e
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -229,56 +253,44 @@ public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -299,18 +311,11 @@ public override void Write(XmlWriter xmlWriter, IMembershipExpose poco, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMembershipExpose" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipExpose poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipExpose poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MembershipExpose");
@@ -337,22 +342,35 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipExpose poc
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.importedElement != null && poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "importedElement", null, poco.importedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.ImportedMembership != null && poco.ImportedMembership.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "importedMembership", null, poco.ImportedMembership.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (poco.IsImportAll)
+            if (!poco.IsImportAll)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isImportAll", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isImportAll", null, "false");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -365,7 +383,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipExpose poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isRecursive", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -373,7 +391,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipExpose poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -381,7 +415,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipExpose poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -389,60 +423,61 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipExpose poc
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Protected)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedElement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.importedElement, "importedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
             if (poco.ImportedMembership != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.importOwningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ImportedMembership.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -451,7 +486,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipExpose poc
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -459,62 +494,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipExpose poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs
index 13a3dbd18..2700a7cc0 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipImportWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MembershipImportWriter" /> is to write an instance of <see cref="IMembershipImport" />
@@ -69,17 +70,10 @@ public MembershipImportWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMembershipImport" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MembershipImport");
@@ -106,12 +100,25 @@ public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string e
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.importedElement != null && poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("importedElement", poco.importedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.ImportedMembership != null && poco.ImportedMembership.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("importedMembership", poco.ImportedMembership.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -121,7 +128,7 @@ public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string e
                 xmlWriter.WriteAttributeString("isImportAll", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -134,7 +141,7 @@ public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string e
                 xmlWriter.WriteAttributeString("isRecursive", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -142,7 +149,23 @@ public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -150,7 +173,7 @@ public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -158,11 +181,14 @@ public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string e
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Private)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -173,45 +199,43 @@ public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedElement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
             if (poco.ImportedMembership != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.importOwningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ImportedMembership.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -220,7 +244,7 @@ public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string e
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -228,56 +252,44 @@ public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -298,18 +310,11 @@ public override void Write(XmlWriter xmlWriter, IMembershipImport poco, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMembershipImport" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MembershipImport");
@@ -336,12 +341,25 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poc
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.importedElement != null && poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "importedElement", null, poco.importedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.ImportedMembership != null && poco.ImportedMembership.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "importedMembership", null, poco.ImportedMembership.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -351,7 +369,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isImportAll", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -364,7 +382,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isRecursive", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -372,7 +390,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -380,7 +414,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -388,60 +422,61 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poc
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Private)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedElement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.importedElement, "importedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
             if (poco.ImportedMembership != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.importOwningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ImportedMembership.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ImportedMembership, "importedMembership", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -450,7 +485,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poc
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -458,62 +493,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembershipImport poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs
index c956384d0..ff65c9f0e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MembershipWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MembershipWriter" /> is to write an instance of <see cref="IMembership" />
@@ -69,17 +70,10 @@ public MembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Membership");
@@ -111,12 +105,12 @@ public override void Write(XmlWriter xmlWriter, IMembership poco, string element
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +118,12 @@ public override void Write(XmlWriter xmlWriter, IMembership poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.WriteIdRefAsAttribute && poco.MemberElement != null && poco.MemberElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("memberElement", poco.MemberElement.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.memberElementId))
                 {
@@ -142,7 +141,7 @@ public override void Write(XmlWriter xmlWriter, IMembership poco, string element
                 xmlWriter.WriteAttributeString("memberShortName", poco.MemberShortName);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -150,7 +149,23 @@ public override void Write(XmlWriter xmlWriter, IMembership poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -158,7 +173,7 @@ public override void Write(XmlWriter xmlWriter, IMembership poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -166,11 +181,14 @@ public override void Write(XmlWriter xmlWriter, IMembership poco, string element
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -183,35 +201,30 @@ public override void Write(XmlWriter xmlWriter, IMembership poco, string element
 
             if (poco.MemberElement != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.MemberElement, "memberElement", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.membershipOwningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.MemberElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.MemberElement, "memberElement", elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -220,7 +233,7 @@ public override void Write(XmlWriter xmlWriter, IMembership poco, string element
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -228,56 +241,44 @@ public override void Write(XmlWriter xmlWriter, IMembership poco, string element
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -298,18 +299,11 @@ public override void Write(XmlWriter xmlWriter, IMembership poco, string element
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Membership");
@@ -341,12 +335,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -354,7 +348,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.WriteIdRefAsAttribute && poco.MemberElement != null && poco.MemberElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "memberElement", null, poco.MemberElement.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.memberElementId))
                 {
@@ -372,7 +371,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "memberShortName", null, poco.MemberShortName);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -380,7 +379,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -388,7 +403,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -396,52 +411,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, str
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
             if (poco.MemberElement != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.MemberElement, "memberElement", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.membershipOwningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.MemberElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.MemberElement, "memberElement", elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -450,7 +463,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, str
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -458,62 +471,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMembership poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs
index e7cac3cbe..7ace31e4b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MergeNodeWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MergeNodeWriter" /> is to write an instance of <see cref="IMergeNode" />
@@ -97,17 +98,10 @@ public MergeNodeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMergeNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MergeNode");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,40 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +175,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +198,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -197,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -210,9 +239,9 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -220,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -228,7 +257,15 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -236,9 +273,76 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -246,7 +350,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -256,7 +360,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -267,7 +371,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -278,15 +382,18 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -297,7 +404,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -308,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -319,7 +426,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -330,15 +437,18 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -349,7 +459,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -360,15 +470,18 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -379,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -390,15 +503,18 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -409,7 +525,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -420,7 +536,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -431,7 +547,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -442,18 +558,18 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -464,15 +580,18 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -483,7 +602,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -494,7 +613,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -505,7 +624,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -516,7 +635,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -527,7 +646,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -538,7 +657,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -549,18 +668,18 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -571,7 +690,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -582,7 +701,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -593,7 +712,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -604,7 +723,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -615,7 +734,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -626,7 +745,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -637,7 +756,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -648,7 +767,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -659,7 +778,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -670,7 +789,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -681,7 +800,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -692,7 +811,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -703,7 +822,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -714,7 +833,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -725,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -736,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -747,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -758,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -769,7 +888,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -780,7 +899,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -791,67 +910,67 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -862,7 +981,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -873,99 +992,99 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -973,127 +1092,121 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1104,7 +1217,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1115,7 +1228,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1126,7 +1239,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1137,7 +1250,7 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1148,13 +1261,13 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1169,18 +1282,11 @@ public override void Write(XmlWriter xmlWriter, IMergeNode poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMergeNode" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MergeNode");
@@ -1192,6 +1298,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1202,13 +1316,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1219,7 +1360,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1242,7 +1383,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1252,7 +1393,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1270,7 +1411,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1283,9 +1424,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1293,7 +1434,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1301,7 +1442,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1309,9 +1458,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1319,7 +1535,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1329,716 +1545,731 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2046,188 +2277,182 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMergeNode poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs
index 265003cde..7128f6854 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetaclassWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Metadata;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MetaclassWriter" /> is to write an instance of <see cref="IMetaclass" />
@@ -73,17 +74,10 @@ public MetaclassWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMetaclass" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Metaclass");
@@ -115,7 +109,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -123,12 +117,12 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -141,7 +135,15 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -149,7 +151,31 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -157,7 +183,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -167,7 +193,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -178,7 +204,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -189,7 +215,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -200,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -211,7 +237,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -222,7 +248,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -233,7 +259,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -244,7 +270,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -255,7 +281,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -266,7 +292,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -277,7 +303,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -288,18 +314,18 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -310,15 +336,18 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -329,59 +358,59 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -392,7 +421,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -403,57 +432,57 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -462,73 +491,66 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -539,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -560,18 +582,11 @@ public override void Write(XmlWriter xmlWriter, IMetaclass poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMetaclass" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMetaclass poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMetaclass poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Metaclass");
@@ -603,7 +618,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetaclass poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -611,12 +626,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetaclass poco, stri
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -629,7 +644,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetaclass poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -637,7 +660,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetaclass poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -645,7 +692,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetaclass poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -655,293 +702,296 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetaclass poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -950,90 +1000,83 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetaclass poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs
index 372e4115a..cef6a1ac1 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataAccessExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MetadataAccessExpressionWriter" /> is to write an instance of <see cref="IMetadataAccessExpression" />
@@ -74,17 +75,10 @@ public MetadataAccessExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMetadataAccessExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataAccessExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,40 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +175,12 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +188,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +211,9 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +221,15 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +237,55 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +293,23 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referencedElement != null && poco.referencedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("referencedElement", poco.referencedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -218,7 +319,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -229,15 +330,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -248,7 +352,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -259,7 +363,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -270,15 +374,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -289,7 +396,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -300,15 +407,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -319,15 +429,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -338,7 +451,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -349,7 +462,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -360,7 +473,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -371,7 +484,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -382,18 +495,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -404,15 +517,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -423,67 +539,67 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -494,7 +610,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -505,99 +621,99 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -605,111 +721,99 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -720,23 +824,29 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referencedElement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedElement, "referencedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referencedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedElement, "referencedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -747,7 +857,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -758,7 +868,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -779,18 +889,11 @@ public override void Write(XmlWriter xmlWriter, IMetadataAccessExpression poco,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMetadataAccessExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MetadataAccessExpression");
@@ -802,6 +905,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -812,13 +923,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -829,7 +967,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -852,12 +990,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -865,7 +1003,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -888,9 +1026,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -898,7 +1036,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -906,7 +1052,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -914,7 +1108,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referencedElement != null && poco.referencedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "referencedElement", null, poco.referencedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -924,386 +1134,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1311,166 +1536,160 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataAccessExpres
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referencedElement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referencedElement, "referencedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referencedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.referencedElement, "referencedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs
index 288a1aa45..17ec89c47 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Metadata;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MetadataDefinitionWriter" /> is to write an instance of <see cref="IMetadataDefinition" />
@@ -94,17 +95,10 @@ public MetadataDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogge
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMetadataDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataDefinition");
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,7 +138,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -154,7 +148,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -172,7 +166,15 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -180,7 +182,31 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -188,7 +214,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -198,7 +224,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -209,7 +235,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -220,7 +246,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -231,7 +257,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -242,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -253,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -264,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -275,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -286,7 +312,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -297,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -308,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -319,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -330,18 +356,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -352,15 +378,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -371,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -382,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -393,7 +422,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -404,18 +433,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -426,7 +455,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -437,7 +466,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -448,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -459,26 +488,26 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -489,40 +518,40 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -533,7 +562,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -544,7 +573,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -555,18 +584,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -577,18 +606,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -599,18 +628,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -621,29 +650,29 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -654,7 +683,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -665,7 +694,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -676,7 +705,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -687,7 +716,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -702,11 +731,11 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -717,7 +746,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -728,18 +757,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -750,18 +779,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -772,18 +801,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -794,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -805,7 +834,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -816,7 +845,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -827,7 +856,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -838,36 +867,29 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -878,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -889,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -900,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -911,13 +933,13 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -932,18 +954,11 @@ public override void Write(XmlWriter xmlWriter, IMetadataDefinition poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMetadataDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MetadataDefinition");
@@ -975,7 +990,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition p
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -983,7 +998,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition p
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -993,7 +1008,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition p
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1011,7 +1026,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition p
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1019,7 +1042,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition p
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1027,7 +1074,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition p
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1037,502 +1084,505 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition p
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1541,222 +1591,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataDefinition p
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs
index e24c527f6..b5464eaed 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataFeatureWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Metadata;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MetadataFeatureWriter" /> is to write an instance of <see cref="IMetadataFeature" />
@@ -72,17 +73,10 @@ public MetadataFeatureWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMetadataFeature" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataFeature");
@@ -94,6 +88,14 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -104,13 +106,32 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -121,7 +142,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,12 +165,12 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -172,9 +193,9 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -182,7 +203,23 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.metaclass != null && poco.metaclass.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("metaclass", poco.metaclass.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -190,7 +227,55 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -198,7 +283,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -208,18 +293,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
@@ -230,7 +315,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -241,15 +326,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -260,7 +348,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -271,7 +359,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -282,7 +370,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -293,15 +381,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -312,7 +403,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -323,15 +414,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -342,7 +436,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -353,7 +447,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -364,7 +458,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -375,7 +469,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -386,7 +480,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -397,18 +491,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -419,23 +513,29 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.metaclass != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.metaclass, "metaclass", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.metaclass.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.metaclass, "metaclass", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -446,78 +546,78 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -528,7 +628,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -539,99 +639,99 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -639,119 +739,99 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -762,7 +842,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -773,7 +853,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -794,18 +874,11 @@ public override void Write(XmlWriter xmlWriter, IMetadataFeature poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMetadataFeature" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MetadataFeature");
@@ -817,6 +890,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -827,13 +908,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -844,7 +944,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -867,12 +967,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -895,9 +995,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -905,7 +1005,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.metaclass != null && poco.metaclass.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "metaclass", null, poco.metaclass.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -913,7 +1029,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -921,7 +1085,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -931,430 +1095,445 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "annotatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.metaclass != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.metaclass, "metaclass", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.metaclass.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.metaclass, "metaclass", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1362,147 +1541,127 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataFeature poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs
index 81514aef9..782ee2c88 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MetadataUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Metadata;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MetadataUsageWriter" /> is to write an instance of <see cref="IMetadataUsage" />
@@ -98,17 +99,10 @@ public MetadataUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFact
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMetadataUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MetadataUsage");
@@ -120,6 +114,14 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +132,40 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +176,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +199,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -198,7 +227,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -211,9 +240,9 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -221,7 +250,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -229,7 +258,23 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.metadataDefinition != null && poco.metadataDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("metadataDefinition", poco.metadataDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -237,9 +282,76 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -247,7 +359,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -257,18 +369,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
@@ -279,7 +391,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -290,15 +402,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -309,7 +424,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -320,7 +435,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -331,7 +446,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -342,7 +457,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -353,15 +468,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -372,7 +490,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -383,15 +501,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -402,7 +523,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -413,15 +534,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -432,7 +556,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -443,7 +567,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -454,7 +578,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -465,7 +589,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
@@ -476,18 +600,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -498,23 +622,29 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.metadataDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.metadataDefinition, "metadataDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.metadataDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.metadataDefinition, "metadataDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -525,7 +655,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -536,7 +666,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -547,7 +677,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -558,7 +688,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -569,7 +699,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -580,7 +710,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -591,18 +721,18 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -613,7 +743,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -624,7 +754,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -635,7 +765,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -646,7 +776,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -657,7 +787,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -668,7 +798,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -679,7 +809,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -690,7 +820,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -701,7 +831,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -712,7 +842,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -723,7 +853,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -734,7 +864,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -745,7 +875,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -756,7 +886,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -767,7 +897,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -778,7 +908,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -789,7 +919,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -800,7 +930,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -811,7 +941,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -822,7 +952,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -833,78 +963,78 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -915,7 +1045,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -926,99 +1056,99 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1026,135 +1156,121 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1165,7 +1281,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1176,7 +1292,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1187,7 +1303,7 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1198,13 +1314,13 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1219,18 +1335,11 @@ public override void Write(XmlWriter xmlWriter, IMetadataUsage poco, string elem
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMetadataUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MetadataUsage");
@@ -1242,6 +1351,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1252,13 +1369,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1269,7 +1413,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1292,7 +1436,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1302,7 +1446,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1320,7 +1464,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1333,9 +1477,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1343,7 +1487,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1351,7 +1495,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.metadataDefinition != null && poco.metadataDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "metadataDefinition", null, poco.metadataDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1359,9 +1519,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1369,7 +1596,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1379,768 +1606,786 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotatedElement != null)
                 {
                     foreach (var item in poco.annotatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "annotatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.metadataDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.metadataDefinition, "metadataDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.metadataDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.metadataDefinition, "metadataDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2148,185 +2393,171 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMetadataUsage poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs
index 0e9820767..e6ce00fc7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityRangeWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Multiplicities;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MultiplicityRangeWriter" /> is to write an instance of <see cref="IMultiplicityRange" />
@@ -73,17 +74,10 @@ public MultiplicityRangeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMultiplicityRange" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:MultiplicityRange");
@@ -95,6 +89,14 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -105,13 +107,32 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -122,7 +143,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -145,12 +166,12 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -173,9 +194,9 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -183,7 +204,23 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.lowerBound != null && poco.lowerBound.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("lowerBound", poco.lowerBound.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -191,7 +228,55 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -199,7 +284,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -207,9 +292,17 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.upperBound != null && poco.upperBound.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("upperBound", poco.upperBound.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.bound != null)
                 {
@@ -220,7 +313,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -231,15 +324,18 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -250,7 +346,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -261,7 +357,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -272,7 +368,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -283,15 +379,18 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -302,7 +401,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -313,15 +412,18 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -332,7 +434,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -343,7 +445,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -354,7 +456,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -365,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -376,7 +478,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -387,26 +489,29 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.lowerBound != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.lowerBound, "lowerBound", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.lowerBound.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.lowerBound, "lowerBound", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -417,15 +522,18 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -436,67 +544,67 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -507,7 +615,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -518,99 +626,99 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -618,111 +726,99 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -733,7 +829,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -744,7 +840,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -755,11 +851,14 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.upperBound != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.upperBound, "upperBound", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.upperBound.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.upperBound, "upperBound", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
@@ -773,18 +872,11 @@ public override void Write(XmlWriter xmlWriter, IMultiplicityRange poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMultiplicityRange" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:MultiplicityRange");
@@ -796,6 +888,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange po
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -806,13 +906,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange po
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -823,7 +942,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange po
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -846,12 +965,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange po
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -874,9 +993,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange po
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -884,7 +1003,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange po
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.lowerBound != null && poco.lowerBound.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "lowerBound", null, poco.lowerBound.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -892,7 +1027,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -900,7 +1083,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -908,410 +1091,433 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange po
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.upperBound != null && poco.upperBound.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "upperBound", null, poco.upperBound.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.bound != null)
                 {
                     foreach (var item in poco.bound)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "bound", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "bound", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.lowerBound != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.lowerBound, "lowerBound", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.lowerBound.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.lowerBound, "lowerBound", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1319,148 +1525,139 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicityRange po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.upperBound != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.upperBound, "upperBound", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.upperBound.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.upperBound, "upperBound", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs
index 502ade197..f70e9ec64 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/MultiplicityWriter.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="MultiplicityWriter" /> is to write an instance of <see cref="IMultiplicity" />
@@ -71,17 +72,10 @@ public MultiplicityWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFacto
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMultiplicity" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Multiplicity");
@@ -93,6 +87,14 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -103,13 +105,32 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -120,7 +141,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -143,12 +164,12 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -171,9 +192,9 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -181,7 +202,15 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -189,7 +218,55 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +274,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -207,7 +284,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -218,15 +295,18 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -237,7 +317,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -248,7 +328,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -259,7 +339,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -270,15 +350,18 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -289,7 +372,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -300,15 +383,18 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -319,7 +405,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -330,7 +416,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -341,7 +427,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -352,7 +438,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -363,7 +449,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -374,18 +460,18 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -396,15 +482,18 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -415,67 +504,67 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -486,7 +575,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -497,99 +586,99 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -597,111 +686,99 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -712,7 +789,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -723,7 +800,7 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -744,18 +821,11 @@ public override void Write(XmlWriter xmlWriter, IMultiplicity poco, string eleme
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IMultiplicity" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Multiplicity");
@@ -767,6 +837,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -777,13 +855,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -794,7 +891,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -817,12 +914,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -845,9 +942,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -855,7 +952,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -863,7 +968,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -871,7 +1024,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -881,389 +1034,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, s
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1271,139 +1436,127 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IMultiplicity poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs
index 2ce578c56..2aeda3a1a 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceExposeWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="NamespaceExposeWriter" /> is to write an instance of <see cref="INamespaceExpose" />
@@ -70,17 +71,10 @@ public NamespaceExposeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="INamespaceExpose" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:NamespaceExpose");
@@ -107,22 +101,35 @@ public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string el
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.importedElement != null && poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("importedElement", poco.importedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.ImportedNamespace != null && poco.ImportedNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("importedNamespace", poco.ImportedNamespace.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (poco.IsImportAll)
+            if (!poco.IsImportAll)
             {
-                xmlWriter.WriteAttributeString("isImportAll", "true");
+                xmlWriter.WriteAttributeString("isImportAll", "false");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -135,7 +142,7 @@ public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string el
                 xmlWriter.WriteAttributeString("isRecursive", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -143,7 +150,23 @@ public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -151,7 +174,7 @@ public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -159,11 +182,14 @@ public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string el
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Protected)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -174,45 +200,43 @@ public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedElement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
             if (poco.ImportedNamespace != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.importOwningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ImportedNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -221,7 +245,7 @@ public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string el
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -229,56 +253,44 @@ public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -299,18 +311,11 @@ public override void Write(XmlWriter xmlWriter, INamespaceExpose poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="INamespaceExpose" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceExpose poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceExpose poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:NamespaceExpose");
@@ -337,22 +342,35 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceExpose poco
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.importedElement != null && poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "importedElement", null, poco.importedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.ImportedNamespace != null && poco.ImportedNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "importedNamespace", null, poco.ImportedNamespace.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (poco.IsImportAll)
+            if (!poco.IsImportAll)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isImportAll", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isImportAll", null, "false");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -365,7 +383,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceExpose poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isRecursive", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -373,7 +391,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceExpose poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -381,7 +415,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceExpose poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -389,60 +423,61 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceExpose poco
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Protected)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedElement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.importedElement, "importedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
             if (poco.ImportedNamespace != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.importOwningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ImportedNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -451,7 +486,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceExpose poco
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -459,62 +494,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceExpose poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs
index 1e29eacd5..975e7e5dc 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceImportWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="NamespaceImportWriter" /> is to write an instance of <see cref="INamespaceImport" />
@@ -69,17 +70,10 @@ public NamespaceImportWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="INamespaceImport" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:NamespaceImport");
@@ -106,12 +100,25 @@ public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string el
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.importedElement != null && poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("importedElement", poco.importedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.ImportedNamespace != null && poco.ImportedNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("importedNamespace", poco.ImportedNamespace.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -121,7 +128,7 @@ public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string el
                 xmlWriter.WriteAttributeString("isImportAll", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -134,7 +141,7 @@ public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string el
                 xmlWriter.WriteAttributeString("isRecursive", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -142,7 +149,23 @@ public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -150,7 +173,7 @@ public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -158,11 +181,14 @@ public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string el
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Private)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -173,45 +199,43 @@ public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedElement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
             if (poco.ImportedNamespace != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.importOwningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ImportedNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -220,7 +244,7 @@ public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string el
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -228,56 +252,44 @@ public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -298,18 +310,11 @@ public override void Write(XmlWriter xmlWriter, INamespaceImport poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="INamespaceImport" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:NamespaceImport");
@@ -336,12 +341,25 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.importedElement != null && poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "importedElement", null, poco.importedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.ImportedNamespace != null && poco.ImportedNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "importedNamespace", null, poco.ImportedNamespace.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -351,7 +369,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isImportAll", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -364,7 +382,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isRecursive", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -372,7 +390,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -380,7 +414,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -388,60 +422,61 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Private)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedElement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importedElement, "importedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.importedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.importedElement, "importedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
             if (poco.ImportedNamespace != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.importOwningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ImportedNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.importOwningNamespace, "importOwningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ImportedNamespace, "importedNamespace", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -450,7 +485,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -458,62 +493,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespaceImport poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs
index 69e9082ab..3f2815418 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NamespaceWriter.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="NamespaceWriter" /> is to write an instance of <see cref="INamespace" />
@@ -68,17 +69,10 @@ public NamespaceWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="INamespace" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, INamespace poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, INamespace poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Namespace");
@@ -105,12 +99,12 @@ public override void Write(XmlWriter xmlWriter, INamespace poco, string elementN
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -118,7 +112,7 @@ public override void Write(XmlWriter xmlWriter, INamespace poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -126,7 +120,23 @@ public override void Write(XmlWriter xmlWriter, INamespace poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -134,7 +144,7 @@ public override void Write(XmlWriter xmlWriter, INamespace poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -144,7 +154,7 @@ public override void Write(XmlWriter xmlWriter, INamespace poco, string elementN
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -155,7 +165,7 @@ public override void Write(XmlWriter xmlWriter, INamespace poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -166,18 +176,18 @@ public override void Write(XmlWriter xmlWriter, INamespace poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -188,57 +198,57 @@ public override void Write(XmlWriter xmlWriter, INamespace poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -247,40 +257,33 @@ public override void Write(XmlWriter xmlWriter, INamespace poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -301,18 +304,11 @@ public override void Write(XmlWriter xmlWriter, INamespace poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="INamespace" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, INamespace poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, INamespace poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Namespace");
@@ -339,12 +335,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespace poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -352,7 +348,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespace poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -360,7 +356,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespace poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -368,7 +380,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespace poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -378,101 +390,101 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespace poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -481,46 +493,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INamespace poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs
index b6e3115ff..2d044d9a3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/NullExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="NullExpressionWriter" /> is to write an instance of <see cref="INullExpression" />
@@ -74,17 +75,10 @@ public NullExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="INullExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, INullExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, INullExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:NullExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,40 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +175,12 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +188,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +211,9 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +221,15 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,7 +237,55 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -208,7 +293,15 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -218,7 +311,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -229,15 +322,18 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -248,7 +344,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -259,7 +355,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -270,15 +366,18 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -289,7 +388,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -300,15 +399,18 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -319,15 +421,18 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -338,7 +443,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -349,7 +454,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -360,7 +465,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -371,7 +476,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -382,18 +487,18 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -404,15 +509,18 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -423,67 +531,67 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -494,7 +602,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -505,99 +613,99 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -605,111 +713,99 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -720,15 +816,18 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -739,7 +838,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -750,7 +849,7 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -771,18 +870,11 @@ public override void Write(XmlWriter xmlWriter, INullExpression poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="INullExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:NullExpression");
@@ -794,6 +886,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -804,13 +904,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -821,7 +948,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -844,12 +971,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -857,7 +984,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -880,9 +1007,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -890,7 +1017,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -898,7 +1033,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -906,7 +1089,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -916,386 +1107,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1303,158 +1509,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, INullExpression poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs
index de4c573b5..02c3a6b69 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ObjectiveMembershipWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Systems.Cases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ObjectiveMembershipWriter" /> is to write an instance of <see cref="IObjectiveMembership" />
@@ -73,17 +74,10 @@ public ObjectiveMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IObjectiveMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ObjectiveMembership");
@@ -115,12 +109,12 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -128,7 +122,7 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -144,7 +138,7 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -152,7 +146,7 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -160,7 +154,31 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedObjectiveRequirement != null && poco.ownedObjectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedObjectiveRequirement", poco.ownedObjectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -168,7 +186,7 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -176,11 +194,14 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -191,33 +212,33 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedObjectiveRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedObjectiveRequirement, "ownedObjectiveRequirement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedObjectiveRequirement, "ownedObjectiveRequirement", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -225,7 +246,7 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -233,64 +254,44 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -311,18 +312,11 @@ public override void Write(XmlWriter xmlWriter, IObjectiveMembership poco, strin
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IObjectiveMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ObjectiveMembership");
@@ -354,12 +348,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -367,7 +361,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -375,7 +369,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -383,7 +377,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -391,7 +385,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -399,7 +393,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedObjectiveRequirement != null && poco.ownedObjectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedObjectiveRequirement", null, poco.ownedObjectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -407,7 +425,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -415,48 +433,51 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedObjectiveRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedObjectiveRequirement, "ownedObjectiveRequirement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedObjectiveRequirement, "ownedObjectiveRequirement", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -464,7 +485,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -472,70 +493,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IObjectiveMembership
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs
index b7ba3dcb3..515e5c222 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="OccurrenceDefinitionWriter" /> is to write an instance of <see cref="IOccurrenceDefinition" />
@@ -94,17 +95,10 @@ public OccurrenceDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IOccurrenceDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OccurrenceDefinition");
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,7 +138,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -154,7 +148,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -172,7 +166,15 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -180,7 +182,31 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -188,7 +214,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -198,7 +224,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -209,7 +235,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -220,7 +246,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -231,7 +257,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -242,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -253,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -264,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -275,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -286,7 +312,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -297,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -308,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -319,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -330,18 +356,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -352,15 +378,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -371,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -382,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -393,7 +422,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -404,18 +433,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -426,7 +455,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -437,7 +466,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -448,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -459,26 +488,26 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -489,40 +518,40 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -533,7 +562,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -544,7 +573,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -555,18 +584,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -577,18 +606,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -599,18 +628,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -621,29 +650,29 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -654,7 +683,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -665,7 +694,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -676,7 +705,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -687,7 +716,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -702,11 +731,11 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -717,7 +746,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -728,18 +757,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -750,18 +779,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -772,18 +801,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -794,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -805,7 +834,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -816,7 +845,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -827,7 +856,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -838,36 +867,29 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -878,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -889,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -900,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -911,13 +933,13 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -932,18 +954,11 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceDefinition poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IOccurrenceDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:OccurrenceDefinition");
@@ -975,7 +990,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -983,7 +998,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -993,7 +1008,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1011,7 +1026,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1019,7 +1042,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1027,7 +1074,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1037,502 +1084,505 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1541,222 +1591,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceDefinition
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs
index 945b7edaf..f9c123957 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OccurrenceUsageWriter.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="OccurrenceUsageWriter" /> is to write an instance of <see cref="IOccurrenceUsage" />
@@ -96,17 +97,10 @@ public OccurrenceUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IOccurrenceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OccurrenceUsage");
@@ -118,6 +112,14 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -128,13 +130,40 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -145,7 +174,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -168,7 +197,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -178,7 +207,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -196,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -209,9 +238,9 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -219,7 +248,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -227,7 +256,15 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -235,9 +272,76 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -245,7 +349,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -255,7 +359,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -266,15 +370,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -285,7 +392,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -296,7 +403,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -307,7 +414,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -318,7 +425,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -329,15 +436,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -348,7 +458,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -359,15 +469,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -378,7 +491,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -389,15 +502,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -408,7 +524,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -419,7 +535,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -430,7 +546,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -441,18 +557,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -463,15 +579,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -482,7 +601,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -493,7 +612,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -504,7 +623,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -515,7 +634,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -526,7 +645,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -537,7 +656,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -548,18 +667,18 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -570,7 +689,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -581,7 +700,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -592,7 +711,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -603,7 +722,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -614,7 +733,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -625,7 +744,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -636,7 +755,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -647,7 +766,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -658,7 +777,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -669,7 +788,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -680,7 +799,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -691,7 +810,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -702,7 +821,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -713,7 +832,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -724,7 +843,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -735,7 +854,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -746,7 +865,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -757,7 +876,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -768,7 +887,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -779,7 +898,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -790,67 +909,67 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -861,7 +980,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -872,99 +991,99 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -972,127 +1091,121 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1103,7 +1216,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1114,7 +1227,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1125,7 +1238,7 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1136,13 +1249,13 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1157,18 +1270,11 @@ public override void Write(XmlWriter xmlWriter, IOccurrenceUsage poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IOccurrenceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:OccurrenceUsage");
@@ -1180,6 +1286,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1190,13 +1304,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1207,7 +1348,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1230,7 +1371,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1240,7 +1381,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1258,7 +1399,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1271,9 +1412,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1281,7 +1422,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1289,7 +1430,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1297,9 +1446,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1307,7 +1523,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1317,716 +1533,731 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2034,177 +2265,171 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOccurrenceUsage poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs
index 65ac9b588..1ac25bc33 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OperatorExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="OperatorExpressionWriter" /> is to write an instance of <see cref="IOperatorExpression" />
@@ -74,17 +75,10 @@ public OperatorExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogge
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IOperatorExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OperatorExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,48 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("instantiatedType", poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +160,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +183,12 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +196,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +219,9 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +229,15 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -205,7 +250,55 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 xmlWriter.WriteAttributeString("operator", poco.Operator);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -213,7 +306,15 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -223,7 +324,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
@@ -234,7 +335,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -245,15 +346,18 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -264,7 +368,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -275,7 +379,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -286,15 +390,18 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -305,7 +412,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -316,15 +423,18 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -335,15 +445,18 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -354,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -365,7 +478,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -376,7 +489,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -387,15 +500,18 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -406,18 +522,18 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -428,15 +544,18 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -447,67 +566,67 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -518,7 +637,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -529,99 +648,99 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -629,111 +748,99 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -744,15 +851,18 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -763,7 +873,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -774,7 +884,7 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -795,18 +905,11 @@ public override void Write(XmlWriter xmlWriter, IOperatorExpression poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IOperatorExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:OperatorExpression");
@@ -818,6 +921,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -828,13 +939,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "instantiatedType", null, poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -845,7 +991,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -868,12 +1014,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -881,7 +1027,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -904,9 +1050,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -914,7 +1060,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -927,7 +1081,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
                 await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -935,7 +1137,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -945,405 +1155,423 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1351,158 +1579,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOperatorExpression p
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs
index f2a07ad61..7a20dbfa6 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/OwningMembershipWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="OwningMembershipWriter" /> is to write an instance of <see cref="IOwningMembership" />
@@ -69,17 +70,10 @@ public OwningMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IOwningMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:OwningMembership");
@@ -111,12 +105,12 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +118,7 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -132,7 +126,15 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedMemberElement != null && poco.ownedMemberElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberElement", poco.ownedMemberElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -140,7 +142,7 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -148,7 +150,7 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -156,7 +158,23 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -164,7 +182,7 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -172,11 +190,14 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -187,41 +208,33 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.membershipOwningNamespace != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMemberElement != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberElement, "ownedMemberElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberElement, "ownedMemberElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -229,7 +242,7 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -237,56 +250,44 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -307,18 +308,11 @@ public override void Write(XmlWriter xmlWriter, IOwningMembership poco, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IOwningMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:OwningMembership");
@@ -350,12 +344,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -363,7 +357,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -371,7 +365,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedMemberElement != null && poco.ownedMemberElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberElement", null, poco.ownedMemberElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -379,7 +381,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -387,7 +389,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -395,7 +397,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -403,7 +421,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -411,56 +429,51 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poc
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.membershipOwningNamespace != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMemberElement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedMemberElement, "ownedMemberElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedMemberElement, "ownedMemberElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -468,7 +481,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poc
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -476,62 +489,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IOwningMembership poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs
index fc3cb8be1..d70f74b85 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PackageWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Packages;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="PackageWriter" /> is to write an instance of <see cref="IPackage" />
@@ -70,17 +71,10 @@ public PackageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory lo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPackage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IPackage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPackage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Package");
@@ -107,12 +101,12 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -120,7 +114,7 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -128,7 +122,23 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -136,7 +146,7 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -146,7 +156,7 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -157,7 +167,7 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.filterCondition != null)
                 {
@@ -168,7 +178,7 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -179,18 +189,18 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -201,57 +211,57 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -260,40 +270,33 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -314,18 +317,11 @@ public override void Write(XmlWriter xmlWriter, IPackage poco, string elementNam
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPackage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IPackage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPackage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Package");
@@ -352,12 +348,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPackage poco, string
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -365,7 +361,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPackage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -373,7 +369,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPackage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -381,7 +393,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPackage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -391,112 +403,112 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPackage poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.filterCondition != null)
                 {
                     foreach (var item in poco.filterCondition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "filterCondition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "filterCondition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -505,46 +517,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPackage poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs
index b1d3bee3b..7e3893681 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ParameterMembershipWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Behaviors;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ParameterMembershipWriter" /> is to write an instance of <see cref="IParameterMembership" />
@@ -72,17 +73,10 @@ public ParameterMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IParameterMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IParameterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IParameterMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ParameterMembership");
@@ -114,12 +108,12 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -127,7 +121,7 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -135,7 +129,7 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -143,7 +137,7 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -151,7 +145,15 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedMemberParameter != null && poco.ownedMemberParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberParameter", poco.ownedMemberParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -159,7 +161,23 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -167,7 +185,7 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -175,11 +193,14 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -190,33 +211,33 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMemberParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -224,7 +245,7 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -232,64 +253,44 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -310,18 +311,11 @@ public override void Write(XmlWriter xmlWriter, IParameterMembership poco, strin
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IParameterMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ParameterMembership");
@@ -353,12 +347,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -366,7 +360,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -374,7 +368,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -382,7 +376,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -390,7 +384,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedMemberParameter != null && poco.ownedMemberParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberParameter", null, poco.ownedMemberParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -398,7 +400,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -406,7 +424,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -414,48 +432,51 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMemberParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedMemberParameter, "ownedMemberParameter", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -463,7 +484,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -471,70 +492,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IParameterMembership
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs
index 391847527..5e9d728e8 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartDefinitionWriter.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Parts;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="PartDefinitionWriter" /> is to write an instance of <see cref="IPartDefinition" />
@@ -93,17 +94,10 @@ public PartDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPartDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PartDefinition");
@@ -135,7 +129,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -143,7 +137,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -153,7 +147,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -171,7 +165,15 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -179,7 +181,31 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -187,7 +213,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -197,7 +223,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -208,7 +234,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -219,7 +245,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -230,7 +256,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -241,7 +267,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -252,7 +278,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -263,7 +289,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -274,7 +300,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -285,7 +311,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -296,7 +322,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -307,7 +333,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -318,7 +344,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -329,18 +355,18 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -351,15 +377,18 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -370,7 +399,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -381,7 +410,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -392,7 +421,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -403,18 +432,18 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -425,7 +454,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -436,7 +465,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -447,7 +476,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -458,26 +487,26 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -488,40 +517,40 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -532,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -543,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -554,18 +583,18 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -576,18 +605,18 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -598,18 +627,18 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -620,29 +649,29 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -653,7 +682,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -664,7 +693,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -675,7 +704,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -686,7 +715,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -701,11 +730,11 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -716,7 +745,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -727,18 +756,18 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -749,18 +778,18 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -771,18 +800,18 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -793,7 +822,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -804,7 +833,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -815,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -826,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -837,36 +866,29 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -877,7 +899,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -888,7 +910,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -899,7 +921,7 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -910,13 +932,13 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -931,18 +953,11 @@ public override void Write(XmlWriter xmlWriter, IPartDefinition poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPartDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PartDefinition");
@@ -974,7 +989,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -982,7 +997,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco,
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -992,7 +1007,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1010,7 +1025,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1018,7 +1041,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1026,7 +1073,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1036,502 +1083,505 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1540,222 +1590,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartDefinition poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs
index 55787e53f..2ced60b93 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PartUsageWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Parts;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="PartUsageWriter" /> is to write an instance of <see cref="IPartUsage" />
@@ -97,17 +98,10 @@ public PartUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPartUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PartUsage");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,40 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +175,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +198,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -197,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -210,9 +239,9 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -220,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -228,7 +257,15 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -236,9 +273,76 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -246,7 +350,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -256,7 +360,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -267,15 +371,18 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -286,7 +393,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -297,7 +404,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -308,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -319,7 +426,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -330,15 +437,18 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -349,7 +459,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -360,15 +470,18 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -379,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -390,15 +503,18 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -409,7 +525,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -420,7 +536,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -431,7 +547,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -442,7 +558,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
@@ -453,18 +569,18 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -475,15 +591,18 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -494,7 +613,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -505,7 +624,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -516,7 +635,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -527,7 +646,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -538,7 +657,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -549,7 +668,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -560,18 +679,18 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -582,7 +701,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -593,7 +712,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -604,7 +723,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -615,7 +734,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -626,7 +745,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -637,7 +756,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -648,7 +767,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -659,7 +778,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -670,7 +789,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -681,7 +800,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -692,7 +811,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -703,7 +822,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -714,7 +833,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -725,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -736,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -747,7 +866,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -758,7 +877,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -769,7 +888,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -780,7 +899,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -791,7 +910,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -802,67 +921,67 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -873,7 +992,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -884,99 +1003,99 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -984,127 +1103,121 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.partDefinition != null)
                 {
@@ -1115,7 +1228,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1126,7 +1239,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1137,7 +1250,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1148,7 +1261,7 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1159,13 +1272,13 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1180,18 +1293,11 @@ public override void Write(XmlWriter xmlWriter, IPartUsage poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPartUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PartUsage");
@@ -1203,6 +1309,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1213,13 +1327,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1230,7 +1371,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1253,7 +1394,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1263,7 +1404,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1281,7 +1422,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1294,9 +1435,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1304,7 +1445,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1312,7 +1453,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1320,9 +1469,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1330,7 +1546,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1340,727 +1556,742 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2068,188 +2299,182 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPartUsage poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.partDefinition != null)
                 {
                     foreach (var item in poco.partDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "partDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "partDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs
index 95243ec2c..00513cd2e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PayloadFeatureWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Interactions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="PayloadFeatureWriter" /> is to write an instance of <see cref="IPayloadFeature" />
@@ -72,17 +73,10 @@ public PayloadFeatureWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPayloadFeature" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PayloadFeature");
@@ -94,6 +88,14 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -104,13 +106,32 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -121,7 +142,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,12 +165,12 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -172,9 +193,9 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -182,7 +203,15 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -190,7 +219,55 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -198,7 +275,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -208,7 +285,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -219,15 +296,18 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -238,7 +318,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -249,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -260,7 +340,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -271,15 +351,18 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -290,7 +373,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -301,15 +384,18 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -320,7 +406,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -331,7 +417,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -342,7 +428,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -353,7 +439,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -364,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -375,18 +461,18 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -397,15 +483,18 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -416,67 +505,67 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -487,7 +576,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -498,99 +587,99 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -598,111 +687,99 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -713,7 +790,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -724,7 +801,7 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -745,18 +822,11 @@ public override void Write(XmlWriter xmlWriter, IPayloadFeature poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPayloadFeature" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PayloadFeature");
@@ -768,6 +838,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -778,13 +856,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -795,7 +892,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -818,12 +915,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -846,9 +943,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -856,7 +953,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -864,7 +969,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -872,7 +1025,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -882,389 +1035,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1272,139 +1437,127 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPayloadFeature poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs
index d19bbf237..147a8a721 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PerformActionUsageWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="PerformActionUsageWriter" /> is to write an instance of <see cref="IPerformActionUsage" />
@@ -97,17 +98,10 @@ public PerformActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogge
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPerformActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PerformActionUsage");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,40 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +175,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +198,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -197,11 +226,11 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    xmlWriter.WriteAttributeString("isReference", "true");
+                    xmlWriter.WriteAttributeString("isReference", "false");
                 }
             }
 
@@ -210,9 +239,9 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -220,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -228,7 +257,15 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -236,9 +273,84 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.performedAction != null && poco.performedAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("performedAction", poco.performedAction.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -246,7 +358,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -256,7 +368,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -267,7 +379,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -278,15 +390,18 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -297,7 +412,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -308,7 +423,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -319,7 +434,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -330,15 +445,18 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -349,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -360,15 +478,18 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -379,7 +500,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -390,15 +511,18 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -409,7 +533,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -420,7 +544,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -431,7 +555,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -442,18 +566,18 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -464,15 +588,18 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -483,7 +610,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -494,7 +621,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -505,7 +632,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -516,7 +643,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -527,7 +654,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -538,7 +665,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -549,18 +676,18 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -571,7 +698,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -582,7 +709,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -593,7 +720,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -604,7 +731,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -615,7 +742,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -626,7 +753,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -637,7 +764,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -648,7 +775,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -659,7 +786,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -670,7 +797,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -681,7 +808,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -692,7 +819,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -703,7 +830,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -714,7 +841,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -725,7 +852,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -736,7 +863,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -747,7 +874,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -758,7 +885,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -769,7 +896,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -780,7 +907,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -791,67 +918,67 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -862,7 +989,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -873,99 +1000,99 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -973,127 +1100,121 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1104,15 +1225,18 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.performedAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.performedAction, "performedAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.performedAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.performedAction, "performedAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1123,7 +1247,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1134,7 +1258,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1145,7 +1269,7 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1156,13 +1280,13 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1177,18 +1301,11 @@ public override void Write(XmlWriter xmlWriter, IPerformActionUsage poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPerformActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PerformActionUsage");
@@ -1200,6 +1317,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1210,13 +1335,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1227,7 +1379,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1250,7 +1402,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1260,7 +1412,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1278,11 +1430,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "false");
                 }
             }
 
@@ -1291,9 +1443,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1301,7 +1453,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1309,7 +1461,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1317,9 +1477,84 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.performedAction != null && poco.performedAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "performedAction", null, poco.performedAction.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1327,7 +1562,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1337,716 +1572,731 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2054,196 +2304,193 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPerformActionUsage p
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.performedAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.performedAction, "performedAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.performedAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.performedAction, "performedAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs
index 341065e52..bfdd500e3 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortConjugationWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Ports;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="PortConjugationWriter" /> is to write an instance of <see cref="IPortConjugation" />
@@ -70,17 +71,10 @@ public PortConjugationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPortConjugation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PortConjugation");
@@ -92,6 +86,19 @@ public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.conjugatedPortDefinition != null && poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("conjugatedPortDefinition", poco.conjugatedPortDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.ConjugatedType != null && poco.ConjugatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("conjugatedType", poco.ConjugatedType.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -112,12 +119,12 @@ public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string el
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -125,7 +132,7 @@ public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -133,7 +140,28 @@ public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.WriteIdRefAsAttribute && poco.OriginalPortDefinition != null && poco.OriginalPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("originalPortDefinition", poco.OriginalPortDefinition.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -141,7 +169,7 @@ public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -151,20 +179,26 @@ public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.conjugatedPortDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
             if (poco.ConjugatedType != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ConjugatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -177,27 +211,30 @@ public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string el
 
             if (poco.OriginalPortDefinition != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OriginalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.OriginalPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OriginalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -206,7 +243,7 @@ public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string el
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -214,56 +251,44 @@ public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -284,18 +309,11 @@ public override void Write(XmlWriter xmlWriter, IPortConjugation poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPortConjugation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PortConjugation");
@@ -307,6 +325,19 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.conjugatedPortDefinition != null && poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "conjugatedPortDefinition", null, poco.conjugatedPortDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.ConjugatedType != null && poco.ConjugatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "conjugatedType", null, poco.ConjugatedType.Id.ToString());
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -327,12 +358,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -340,7 +371,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -348,7 +379,28 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.WriteIdRefAsAttribute && poco.OriginalPortDefinition != null && poco.OriginalPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "originalPortDefinition", null, poco.OriginalPortDefinition.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -356,7 +408,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -366,53 +418,62 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.conjugatedPortDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
             if (poco.ConjugatedType != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ConjugatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ConjugatedType, "conjugatedType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
             if (poco.OriginalPortDefinition != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OriginalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.OriginalPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.OriginalPortDefinition, "originalPortDefinition", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -421,7 +482,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -429,62 +490,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortConjugation poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs
index 24fe0234d..197435752 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Ports;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="PortDefinitionWriter" /> is to write an instance of <see cref="IPortDefinition" />
@@ -94,17 +95,10 @@ public PortDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPortDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PortDefinition");
@@ -116,6 +110,14 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.conjugatedPortDefinition != null && poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("conjugatedPortDefinition", poco.conjugatedPortDefinition.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -136,7 +138,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,7 +146,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -154,7 +156,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -172,7 +174,15 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -180,7 +190,31 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -188,7 +222,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -198,15 +232,18 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.conjugatedPortDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -217,7 +254,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -228,7 +265,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -239,7 +276,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -250,7 +287,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -261,7 +298,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -272,7 +309,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -283,7 +320,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -294,7 +331,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -305,7 +342,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -316,7 +353,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -327,7 +364,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -338,18 +375,18 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -360,15 +397,18 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -379,7 +419,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -390,7 +430,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -401,7 +441,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -412,18 +452,18 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -434,7 +474,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -445,7 +485,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -456,7 +496,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -467,26 +507,26 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -497,40 +537,40 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -541,7 +581,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -552,7 +592,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -563,18 +603,18 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -585,18 +625,18 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -607,18 +647,18 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -629,29 +669,29 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -662,7 +702,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -673,7 +713,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -684,7 +724,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -695,7 +735,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -710,11 +750,11 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -725,7 +765,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -736,18 +776,18 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -758,18 +798,18 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -780,18 +820,18 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -802,7 +842,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -813,7 +853,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -824,7 +864,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -835,7 +875,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -846,36 +886,29 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -886,7 +919,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -897,7 +930,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -908,7 +941,7 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -919,13 +952,13 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -940,18 +973,11 @@ public override void Write(XmlWriter xmlWriter, IPortDefinition poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPortDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PortDefinition");
@@ -963,6 +989,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.conjugatedPortDefinition != null && poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "conjugatedPortDefinition", null, poco.conjugatedPortDefinition.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -983,7 +1017,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -991,7 +1025,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco,
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1001,7 +1035,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1019,7 +1053,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1027,7 +1069,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1035,7 +1101,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1045,510 +1111,516 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.conjugatedPortDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.conjugatedPortDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.conjugatedPortDefinition, "conjugatedPortDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1557,222 +1629,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortDefinition poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs
index cd809ae0d..0cc7f0b7f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PortUsageWriter.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Ports;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="PortUsageWriter" /> is to write an instance of <see cref="IPortUsage" />
@@ -96,17 +97,10 @@ public PortUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPortUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:PortUsage");
@@ -118,6 +112,14 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -128,13 +130,40 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -145,7 +174,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -168,7 +197,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -178,7 +207,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -196,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -209,9 +238,9 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -219,7 +248,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -227,7 +256,15 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -235,9 +272,76 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -245,7 +349,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -255,7 +359,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -266,15 +370,18 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -285,7 +392,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -296,7 +403,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -307,7 +414,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -318,7 +425,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -329,15 +436,18 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -348,7 +458,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -359,15 +469,18 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -378,7 +491,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -389,15 +502,18 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -408,7 +524,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -419,7 +535,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -430,7 +546,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -441,18 +557,18 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -463,15 +579,18 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -482,7 +601,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -493,7 +612,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -504,7 +623,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -515,7 +634,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -526,7 +645,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -537,7 +656,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -548,18 +667,18 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -570,7 +689,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -581,7 +700,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -592,7 +711,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -603,7 +722,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -614,7 +733,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -625,7 +744,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -636,7 +755,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -647,7 +766,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -658,7 +777,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -669,7 +788,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -680,7 +799,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -691,7 +810,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -702,7 +821,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -713,7 +832,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -724,7 +843,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -735,7 +854,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -746,7 +865,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -757,7 +876,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -768,7 +887,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -779,67 +898,67 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -850,7 +969,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -861,99 +980,99 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -961,127 +1080,121 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.portDefinition != null)
                 {
@@ -1092,7 +1205,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1103,7 +1216,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1114,7 +1227,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1125,7 +1238,7 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1136,13 +1249,13 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1157,18 +1270,11 @@ public override void Write(XmlWriter xmlWriter, IPortUsage poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPortUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:PortUsage");
@@ -1180,6 +1286,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1190,13 +1304,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1207,7 +1348,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1230,7 +1371,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1240,7 +1381,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1258,7 +1399,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1271,9 +1412,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1281,7 +1422,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1289,7 +1430,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1297,9 +1446,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1307,7 +1523,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1317,705 +1533,720 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2023,188 +2254,182 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPortUsage poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.portDefinition != null)
                 {
                     foreach (var item in poco.portDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "portDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "portDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs
index de9dca975..d8df3a50b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/PredicateWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="PredicateWriter" /> is to write an instance of <see cref="IPredicate" />
@@ -73,17 +74,10 @@ public PredicateWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPredicate" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Predicate");
@@ -115,7 +109,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -123,12 +117,12 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -149,7 +143,15 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -157,7 +159,31 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -165,7 +191,15 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -175,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -186,7 +220,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -197,7 +231,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -208,7 +242,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -219,7 +253,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -230,7 +264,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -241,7 +275,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -252,7 +286,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -263,7 +297,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -274,7 +308,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -285,7 +319,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -296,18 +330,18 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -318,15 +352,18 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -337,59 +374,59 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -400,7 +437,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -411,57 +448,57 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -470,73 +507,66 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -547,15 +577,18 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -566,7 +599,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -577,7 +610,7 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -598,18 +631,11 @@ public override void Write(XmlWriter xmlWriter, IPredicate poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IPredicate" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Predicate");
@@ -641,7 +667,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -649,12 +675,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, stri
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -662,7 +688,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -675,7 +701,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -683,7 +717,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -691,7 +749,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -701,293 +767,296 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -996,120 +1065,116 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IPredicate poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs
index 754325343..ba04f8c67 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RedefinitionWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="RedefinitionWriter" /> is to write an instance of <see cref="IRedefinition" />
@@ -70,17 +71,10 @@ public RedefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFacto
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRedefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IRedefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRedefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Redefinition");
@@ -112,12 +106,12 @@ public override void Write(XmlWriter xmlWriter, IRedefinition poco, string eleme
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -125,7 +119,7 @@ public override void Write(XmlWriter xmlWriter, IRedefinition poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -133,7 +127,23 @@ public override void Write(XmlWriter xmlWriter, IRedefinition poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -141,7 +151,17 @@ public override void Write(XmlWriter xmlWriter, IRedefinition poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.WriteIdRefAsAttribute && poco.RedefinedFeature != null && poco.RedefinedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("redefinedFeature", poco.RedefinedFeature.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.RedefiningFeature != null && poco.RedefiningFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("redefiningFeature", poco.RedefiningFeature.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -151,7 +171,7 @@ public override void Write(XmlWriter xmlWriter, IRedefinition poco, string eleme
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -162,24 +182,24 @@ public override void Write(XmlWriter xmlWriter, IRedefinition poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -188,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IRedefinition poco, string eleme
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -196,74 +216,60 @@ public override void Write(XmlWriter xmlWriter, IRedefinition poco, string eleme
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.owningFeature != null)
+                if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (poco.RedefinedFeature != null)
             {
-                if (poco.owningMembership != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.RedefinedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.RedefinedFeature, "redefinedFeature", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (poco.RedefiningFeature != null)
             {
-                if (poco.owningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.RedefiningFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.RedefiningFeature, "redefiningFeature", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.RedefinedFeature != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.RedefinedFeature, "redefinedFeature", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.RedefiningFeature != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.RedefiningFeature, "redefiningFeature", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -284,18 +290,11 @@ public override void Write(XmlWriter xmlWriter, IRedefinition poco, string eleme
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRedefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IRedefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRedefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Redefinition");
@@ -327,12 +326,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRedefinition poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -340,7 +339,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRedefinition poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -348,7 +347,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRedefinition poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -356,7 +371,17 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRedefinition poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.WriteIdRefAsAttribute && poco.RedefinedFeature != null && poco.RedefinedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "redefinedFeature", null, poco.RedefinedFeature.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.RedefiningFeature != null && poco.RedefiningFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "redefiningFeature", null, poco.RedefiningFeature.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -366,35 +391,35 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRedefinition poco, s
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -403,7 +428,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRedefinition poco, s
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -411,80 +436,66 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRedefinition poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.owningFeature != null)
+                if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (poco.RedefinedFeature != null)
             {
-                if (poco.owningMembership != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.RedefinedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.RedefinedFeature, "redefinedFeature", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (poco.RedefiningFeature != null)
             {
-                if (poco.owningNamespace != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.RedefiningFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.RedefiningFeature, "redefiningFeature", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.RedefinedFeature != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.RedefinedFeature, "redefinedFeature", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.RedefiningFeature != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.RedefiningFeature, "redefiningFeature", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs
index e10dca1da..c6ab8588d 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceSubsettingWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ReferenceSubsettingWriter" /> is to write an instance of <see cref="IReferenceSubsetting" />
@@ -70,17 +71,10 @@ public ReferenceSubsettingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IReferenceSubsetting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ReferenceSubsetting");
@@ -112,12 +106,12 @@ public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, strin
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -125,7 +119,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -133,7 +127,23 @@ public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -141,7 +151,12 @@ public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.WriteIdRefAsAttribute && poco.ReferencedFeature != null && poco.ReferencedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("referencedFeature", poco.ReferencedFeature.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -151,7 +166,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, strin
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -162,24 +177,24 @@ public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -188,7 +203,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, strin
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -196,69 +211,52 @@ public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
             if (poco.ReferencedFeature != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ReferencedFeature, "referencedFeature", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.referencingFeature != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ReferencedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencingFeature, "referencingFeature", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.ReferencedFeature, "referencedFeature", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -279,18 +277,11 @@ public override void Write(XmlWriter xmlWriter, IReferenceSubsetting poco, strin
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IReferenceSubsetting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceSubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceSubsetting poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ReferenceSubsetting");
@@ -322,12 +313,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceSubsetting
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -335,7 +326,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceSubsetting
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -343,7 +334,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceSubsetting
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -351,7 +358,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceSubsetting
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.WriteIdRefAsAttribute && poco.ReferencedFeature != null && poco.ReferencedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "referencedFeature", null, poco.ReferencedFeature.Id.ToString());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -361,35 +373,35 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceSubsetting
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -398,7 +410,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceSubsetting
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -406,75 +418,58 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceSubsetting
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
             if (poco.ReferencedFeature != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.ReferencedFeature, "referencedFeature", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.referencingFeature != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.ReferencedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referencingFeature, "referencingFeature", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.ReferencedFeature, "referencedFeature", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs
index c39b92fa7..9f8d4f271 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReferenceUsageWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ReferenceUsageWriter" /> is to write an instance of <see cref="IReferenceUsage" />
@@ -94,17 +95,10 @@ public ReferenceUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IReferenceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ReferenceUsage");
@@ -116,6 +110,14 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -126,13 +128,32 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -143,7 +164,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -166,12 +187,12 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -189,11 +210,11 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    xmlWriter.WriteAttributeString("isReference", "true");
+                    xmlWriter.WriteAttributeString("isReference", "false");
                 }
             }
 
@@ -202,9 +223,9 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -212,7 +233,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -220,7 +241,15 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -228,7 +257,71 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -236,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -246,7 +339,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -257,15 +350,18 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.definition != null)
                 {
@@ -276,7 +372,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -287,7 +383,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -298,7 +394,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -309,7 +405,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -320,7 +416,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -331,15 +427,18 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -350,7 +449,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -361,15 +460,18 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -380,7 +482,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -391,7 +493,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -402,7 +504,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -413,7 +515,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -424,7 +526,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -435,18 +537,18 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -457,15 +559,18 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -476,7 +581,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -487,7 +592,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -498,7 +603,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -509,7 +614,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -520,7 +625,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -531,7 +636,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -542,18 +647,18 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -564,7 +669,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -575,7 +680,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -586,7 +691,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -597,7 +702,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -608,7 +713,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -619,7 +724,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -630,7 +735,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -641,7 +746,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -652,7 +757,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -663,7 +768,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -674,7 +779,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -685,7 +790,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -696,7 +801,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -707,7 +812,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -718,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -729,7 +834,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -740,7 +845,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -751,7 +856,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -762,7 +867,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -773,67 +878,67 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -844,7 +949,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -855,99 +960,99 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -955,127 +1060,121 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1086,7 +1185,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1097,7 +1196,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1108,7 +1207,7 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1119,13 +1218,13 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1140,18 +1239,11 @@ public override void Write(XmlWriter xmlWriter, IReferenceUsage poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IReferenceUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ReferenceUsage");
@@ -1163,6 +1255,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1173,13 +1273,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1190,7 +1309,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1213,12 +1332,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1236,11 +1355,11 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
-                if (poco.isReference)
+                if (!poco.isReference)
                 {
-                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "true");
+                    await xmlWriter.WriteAttributeStringAsync(null, "isReference", null, "false");
                 }
             }
 
@@ -1249,9 +1368,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1259,7 +1378,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1267,7 +1386,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1275,7 +1402,71 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1283,7 +1474,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1293,708 +1484,720 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.definition != null)
                 {
                     foreach (var item in poco.definition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "definition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2002,177 +2205,171 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReferenceUsage poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs
index e65e0aa79..12b09f4c2 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingDefinitionWriter.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="RenderingDefinitionWriter" /> is to write an instance of <see cref="IRenderingDefinition" />
@@ -93,17 +94,10 @@ public RenderingDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRenderingDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RenderingDefinition");
@@ -135,7 +129,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -143,7 +137,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -153,7 +147,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -171,7 +165,15 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -179,7 +181,31 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -187,7 +213,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -197,7 +223,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -208,7 +234,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -219,7 +245,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -230,7 +256,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -241,7 +267,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -252,7 +278,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -263,7 +289,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -274,7 +300,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -285,7 +311,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -296,7 +322,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -307,7 +333,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -318,7 +344,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -329,18 +355,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -351,15 +377,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -370,7 +399,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -381,7 +410,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -392,7 +421,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -403,18 +432,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -425,7 +454,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -436,7 +465,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -447,7 +476,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -458,26 +487,26 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -488,40 +517,40 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -532,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -543,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -554,18 +583,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -576,18 +605,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -598,18 +627,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -620,29 +649,29 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -653,7 +682,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -664,7 +693,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -675,7 +704,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -686,7 +715,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -701,11 +730,11 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -716,7 +745,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -727,18 +756,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -749,18 +778,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -771,18 +800,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -793,7 +822,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -804,7 +833,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -815,7 +844,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -826,7 +855,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -837,36 +866,29 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.rendering != null)
                 {
@@ -877,7 +899,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -888,7 +910,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -899,7 +921,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -910,7 +932,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -921,13 +943,13 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -942,18 +964,11 @@ public override void Write(XmlWriter xmlWriter, IRenderingDefinition poco, strin
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRenderingDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RenderingDefinition");
@@ -985,7 +1000,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -993,7 +1008,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1003,7 +1018,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1021,7 +1036,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1029,7 +1052,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1037,7 +1084,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1047,502 +1094,505 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1551,233 +1601,226 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingDefinition
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.rendering != null)
                 {
                     foreach (var item in poco.rendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "rendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "rendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs
index 760e884b2..019385927 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RenderingUsageWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="RenderingUsageWriter" /> is to write an instance of <see cref="IRenderingUsage" />
@@ -97,17 +98,10 @@ public RenderingUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRenderingUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RenderingUsage");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,40 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +175,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +198,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -197,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -210,9 +239,9 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -220,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -228,7 +257,15 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -236,9 +273,76 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -246,7 +350,15 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.renderingDefinition != null && poco.renderingDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("renderingDefinition", poco.renderingDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -256,7 +368,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -267,15 +379,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -286,7 +401,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -297,7 +412,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -308,7 +423,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -319,7 +434,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -330,15 +445,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -349,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -360,15 +478,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -379,7 +500,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -390,15 +511,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -409,7 +533,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -420,7 +544,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -431,7 +555,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -442,7 +566,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
@@ -453,18 +577,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -475,15 +599,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -494,7 +621,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -505,7 +632,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -516,7 +643,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -527,7 +654,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -538,7 +665,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -549,7 +676,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -560,18 +687,18 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -582,7 +709,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -593,7 +720,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -604,7 +731,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -615,7 +742,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -626,7 +753,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -637,7 +764,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -648,7 +775,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -659,7 +786,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -670,7 +797,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -681,7 +808,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -692,7 +819,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -703,7 +830,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -714,7 +841,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -725,7 +852,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -736,7 +863,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -747,7 +874,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -758,7 +885,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -769,7 +896,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -780,7 +907,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -791,7 +918,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -802,67 +929,67 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -873,7 +1000,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -884,99 +1011,99 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -984,135 +1111,132 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.renderingDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.renderingDefinition, "renderingDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.renderingDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.renderingDefinition, "renderingDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1123,7 +1247,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1134,7 +1258,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1145,7 +1269,7 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1156,13 +1280,13 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1177,18 +1301,11 @@ public override void Write(XmlWriter xmlWriter, IRenderingUsage poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRenderingUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RenderingUsage");
@@ -1200,6 +1317,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1210,13 +1335,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1227,7 +1379,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1250,7 +1402,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1260,7 +1412,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1278,7 +1430,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1291,9 +1443,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1301,7 +1453,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1309,7 +1461,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1317,9 +1477,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1327,7 +1554,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.renderingDefinition != null && poco.renderingDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "renderingDefinition", null, poco.renderingDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1337,727 +1572,742 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2065,185 +2315,182 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRenderingUsage poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.renderingDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.renderingDefinition, "renderingDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.renderingDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.renderingDefinition, "renderingDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs
index df4b63b0f..c6f32e351 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementConstraintMembershipWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Constraints;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="RequirementConstraintMembershipWriter" /> is to write an instance of <see cref="IRequirementConstraintMembership" />
@@ -74,17 +75,10 @@ public RequirementConstraintMembershipWriter(IXmiDataWriterFacade xmiDataWriterF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRequirementConstraintMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementConstraintMembership");
@@ -116,12 +110,12 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -129,9 +123,9 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
                 }
             }
 
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString().ToLower());
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -139,7 +133,15 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConstraint != null && poco.ownedConstraint.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConstraint", poco.ownedConstraint.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -147,7 +149,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -155,7 +157,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -163,7 +165,23 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -171,7 +189,15 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referencedConstraint != null && poco.referencedConstraint.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("referencedConstraint", poco.referencedConstraint.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -179,11 +205,14 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -194,32 +223,32 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConstraint, "ownedConstraint", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConstraint, "ownedConstraint", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -228,7 +257,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -236,72 +265,55 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referencedConstraint != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedConstraint, "referencedConstraint", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referencedConstraint.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedConstraint, "referencedConstraint", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -322,18 +334,11 @@ public override void Write(XmlWriter xmlWriter, IRequirementConstraintMembership
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRequirementConstraintMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstraintMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstraintMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RequirementConstraintMembership");
@@ -365,12 +370,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstrain
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -378,9 +383,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstrain
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString().ToLower());
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -388,7 +393,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstrain
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConstraint != null && poco.ownedConstraint.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConstraint", null, poco.ownedConstraint.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -396,7 +409,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstrain
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -404,7 +417,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstrain
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -412,7 +425,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstrain
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -420,7 +449,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstrain
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referencedConstraint != null && poco.referencedConstraint.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "referencedConstraint", null, poco.referencedConstraint.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -428,47 +465,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstrain
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConstraint, "ownedConstraint", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConstraint, "ownedConstraint", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -477,7 +517,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstrain
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -485,78 +525,61 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementConstrain
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referencedConstraint != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referencedConstraint, "referencedConstraint", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referencedConstraint.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.referencedConstraint, "referencedConstraint", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs
index 191fe7312..eca6b3838 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementDefinitionWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="RequirementDefinitionWriter" /> is to write an instance of <see cref="IRequirementDefinition" />
@@ -95,17 +96,10 @@ public RequirementDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRequirementDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementDefinition");
@@ -132,7 +126,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -140,7 +134,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -150,7 +144,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -158,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -176,7 +170,15 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -184,7 +186,31 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +223,15 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 xmlWriter.WriteAttributeString("reqId", poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -205,7 +239,15 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -215,7 +257,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -226,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
@@ -237,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -248,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -259,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -270,7 +312,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -281,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -292,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -303,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -314,7 +356,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
@@ -325,7 +367,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -336,7 +378,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -347,7 +389,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -358,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -369,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -380,18 +422,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -402,15 +444,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -421,7 +466,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -432,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -443,7 +488,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -454,18 +499,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -476,7 +521,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -487,7 +532,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -498,7 +543,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -509,26 +554,26 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -539,40 +584,40 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -583,7 +628,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -594,7 +639,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -605,18 +650,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -627,18 +672,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -649,18 +694,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -671,29 +716,29 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -704,7 +749,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -715,7 +760,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -726,7 +771,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -737,7 +782,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -752,11 +797,11 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -767,7 +812,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -778,18 +823,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -800,18 +845,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -822,18 +867,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -844,7 +889,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -855,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -866,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -877,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -888,36 +933,29 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -928,7 +966,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
@@ -939,15 +977,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
@@ -958,7 +999,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -969,15 +1010,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -988,7 +1032,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -999,7 +1043,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1010,7 +1054,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1021,13 +1065,13 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1042,18 +1086,11 @@ public override void Write(XmlWriter xmlWriter, IRequirementDefinition poco, str
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRequirementDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RequirementDefinition");
@@ -1080,7 +1117,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinitio
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1088,7 +1125,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinitio
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1098,7 +1135,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinitio
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1106,7 +1143,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinitio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1124,7 +1161,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinitio
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1132,7 +1177,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinitio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1145,7 +1214,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinitio
                 await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1153,7 +1230,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinitio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -1163,535 +1248,538 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinitio
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1700,282 +1788,281 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementDefinitio
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs
index 6ca94647d..8c7da058a 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="RequirementUsageWriter" /> is to write an instance of <see cref="IRequirementUsage" />
@@ -98,17 +99,10 @@ public RequirementUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRequirementUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementUsage");
@@ -120,18 +114,53 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -142,7 +171,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -165,7 +194,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -175,7 +204,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -183,7 +212,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -201,7 +230,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -214,9 +243,9 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -224,7 +253,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -232,7 +261,15 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -240,9 +277,76 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -255,7 +359,23 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 xmlWriter.WriteAttributeString("reqId", poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.requirementDefinition != null && poco.requirementDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("requirementDefinition", poco.requirementDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -263,7 +383,15 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -273,7 +401,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -284,7 +412,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
@@ -295,7 +423,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -306,15 +434,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -325,7 +456,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -336,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -347,7 +478,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -358,15 +489,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -377,7 +511,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -388,15 +522,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -407,7 +544,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
@@ -418,7 +555,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -429,15 +566,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -448,7 +588,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -459,7 +599,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -470,7 +610,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -481,18 +621,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -503,15 +643,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -522,7 +665,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -533,7 +676,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -544,7 +687,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -555,7 +698,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -566,7 +709,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -577,7 +720,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -588,18 +731,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -610,7 +753,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -621,7 +764,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -632,7 +775,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -643,7 +786,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -654,7 +797,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -665,7 +808,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -676,7 +819,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -687,7 +830,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -698,7 +841,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -709,7 +852,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -720,7 +863,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -731,7 +874,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -742,7 +885,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -753,7 +896,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -764,7 +907,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -775,7 +918,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -786,7 +929,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -797,7 +940,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -808,7 +951,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -819,7 +962,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -830,67 +973,67 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -901,7 +1044,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -912,99 +1055,99 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1012,127 +1155,121 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1143,7 +1280,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
@@ -1154,23 +1291,29 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requirementDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.requirementDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
@@ -1181,15 +1324,18 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1200,7 +1346,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1211,7 +1357,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1222,7 +1368,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1233,13 +1379,13 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1254,18 +1400,11 @@ public override void Write(XmlWriter xmlWriter, IRequirementUsage poco, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRequirementUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RequirementUsage");
@@ -1277,18 +1416,53 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1299,7 +1473,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1322,7 +1496,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1332,7 +1506,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1340,7 +1514,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1358,7 +1532,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1371,9 +1545,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1381,7 +1555,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1389,7 +1563,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1397,9 +1579,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1412,7 +1661,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.requirementDefinition != null && poco.requirementDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "requirementDefinition", null, poco.requirementDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1420,7 +1685,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -1430,738 +1703,753 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2169,234 +2457,237 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementUsage poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requirementDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.requirementDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs
index 52c9ec676..39cd2602f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/RequirementVerificationMembershipWriter.cs
@@ -45,6 +45,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="RequirementVerificationMembershipWriter" /> is to write an instance of <see cref="IRequirementVerificationMembership" />
@@ -75,17 +76,10 @@ public RequirementVerificationMembershipWriter(IXmiDataWriterFacade xmiDataWrite
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRequirementVerificationMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:RequirementVerificationMembership");
@@ -117,12 +111,12 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -130,9 +124,12 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
                 }
             }
 
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            if (poco.Kind != RequirementConstraintKind.Requirement)
+            {
+                xmlWriter.WriteAttributeString("kind", poco.Kind.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -140,7 +137,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -148,7 +145,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -156,7 +153,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -164,7 +161,31 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedRequirement != null && poco.ownedRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedRequirement", poco.ownedRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -172,7 +193,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -180,11 +201,22 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.verifiedRequirement != null && poco.verifiedRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("verifiedRequirement", poco.verifiedRequirement.Id.ToString());
+                }
+            }
+
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -195,24 +227,24 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -221,7 +253,7 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -229,72 +261,52 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedRequirement, "ownedRequirement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedRequirement, "ownedRequirement", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -305,11 +317,14 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.verifiedRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.verifiedRequirement, "verifiedRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.verifiedRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.verifiedRequirement, "verifiedRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
@@ -323,18 +338,11 @@ public override void Write(XmlWriter xmlWriter, IRequirementVerificationMembersh
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IRequirementVerificationMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificationMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificationMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:RequirementVerificationMembership");
@@ -366,12 +374,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificat
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -379,9 +387,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificat
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+            if (poco.Kind != RequirementConstraintKind.Requirement)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -389,7 +400,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificat
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -397,7 +408,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificat
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -405,7 +416,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificat
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -413,7 +424,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificat
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedRequirement != null && poco.ownedRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedRequirement", null, poco.ownedRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -421,7 +456,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificat
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -429,39 +464,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificat
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.verifiedRequirement != null && poco.verifiedRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "verifiedRequirement", null, poco.verifiedRequirement.Id.ToString());
+                }
+            }
+
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -470,7 +516,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificat
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -478,87 +524,70 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IRequirementVerificat
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedRequirement, "ownedRequirement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedRequirement, "ownedRequirement", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.verifiedRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.verifiedRequirement, "verifiedRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.verifiedRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.verifiedRequirement, "verifiedRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs
index bfdd63f74..c546d60f2 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ResultExpressionMembershipWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ResultExpressionMembershipWriter" /> is to write an instance of <see cref="IResultExpressionMembership" />
@@ -72,17 +73,10 @@ public ResultExpressionMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IResultExpressionMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ResultExpressionMembership");
@@ -114,12 +108,12 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -127,7 +121,7 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -135,7 +129,7 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -143,7 +137,7 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -151,7 +145,7 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -159,7 +153,31 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedResultExpression != null && poco.ownedResultExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedResultExpression", poco.ownedResultExpression.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -167,7 +185,7 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -175,11 +193,14 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -190,24 +211,24 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -216,7 +237,7 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -224,72 +245,52 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedResultExpression != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedResultExpression, "ownedResultExpression", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedResultExpression, "ownedResultExpression", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -310,18 +311,11 @@ public override void Write(XmlWriter xmlWriter, IResultExpressionMembership poco
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IResultExpressionMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ResultExpressionMembership");
@@ -353,12 +347,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMemb
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -366,7 +360,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMemb
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -374,7 +368,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMemb
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -382,7 +376,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMemb
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -390,7 +384,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMemb
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -398,7 +392,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMemb
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedResultExpression != null && poco.ownedResultExpression.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedResultExpression", null, poco.ownedResultExpression.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -406,7 +424,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMemb
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -414,39 +432,42 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMemb
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -455,7 +476,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMemb
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -463,78 +484,58 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IResultExpressionMemb
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedResultExpression != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedResultExpression, "ownedResultExpression", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedResultExpression, "ownedResultExpression", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs
index 17d969c2b..46dcff0a4 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ReturnParameterMembershipWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ReturnParameterMembershipWriter" /> is to write an instance of <see cref="IReturnParameterMembership" />
@@ -73,17 +74,10 @@ public ReturnParameterMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IReturnParameterMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ReturnParameterMembership");
@@ -115,12 +109,12 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -128,7 +122,7 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -144,7 +138,7 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -152,7 +146,15 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedMemberParameter != null && poco.ownedMemberParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedMemberParameter", poco.ownedMemberParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -160,7 +162,23 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -168,7 +186,7 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -176,11 +194,14 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -191,33 +212,33 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMemberParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -225,7 +246,7 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -233,64 +254,44 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -311,18 +312,11 @@ public override void Write(XmlWriter xmlWriter, IReturnParameterMembership poco,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IReturnParameterMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ReturnParameterMembership");
@@ -354,12 +348,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembe
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -367,7 +361,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembe
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -375,7 +369,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembe
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -383,7 +377,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembe
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -391,7 +385,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembe
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedMemberParameter != null && poco.ownedMemberParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedMemberParameter", null, poco.ownedMemberParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -399,7 +401,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembe
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -407,7 +425,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembe
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -415,48 +433,51 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembe
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMemberParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedMemberParameter, "ownedMemberParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedMemberParameter, "ownedMemberParameter", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -464,7 +485,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembe
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -472,70 +493,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IReturnParameterMembe
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs
index 1266b299e..227ff5474 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SatisfyRequirementUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SatisfyRequirementUsageWriter" /> is to write an instance of <see cref="ISatisfyRequirementUsage" />
@@ -98,17 +99,10 @@ public SatisfyRequirementUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, I
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISatisfyRequirementUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SatisfyRequirementUsage");
@@ -120,18 +114,53 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -142,7 +171,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -165,7 +194,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -175,7 +204,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -183,7 +212,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -206,7 +235,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -219,9 +248,9 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -229,7 +258,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -237,7 +266,15 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -245,9 +282,76 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -260,7 +364,39 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 xmlWriter.WriteAttributeString("reqId", poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.requirementDefinition != null && poco.requirementDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("requirementDefinition", poco.requirementDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.satisfiedRequirement != null && poco.satisfiedRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("satisfiedRequirement", poco.satisfiedRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.satisfyingFeature != null && poco.satisfyingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("satisfyingFeature", poco.satisfyingFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -268,7 +404,15 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -278,7 +422,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -289,7 +433,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
@@ -300,7 +444,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -311,15 +455,18 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -330,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -341,7 +488,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -352,7 +499,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -363,15 +510,18 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -382,7 +532,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -393,15 +543,18 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -412,7 +565,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
@@ -423,7 +576,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -434,15 +587,18 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -453,7 +609,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -464,7 +620,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -475,7 +631,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -486,18 +642,18 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -508,15 +664,18 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -527,7 +686,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -538,7 +697,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -549,7 +708,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -560,7 +719,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -571,7 +730,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -582,7 +741,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -593,18 +752,18 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -615,7 +774,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -626,7 +785,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -637,7 +796,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -648,7 +807,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -659,7 +818,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -670,7 +829,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -681,7 +840,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -692,7 +851,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -703,7 +862,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -714,7 +873,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -725,7 +884,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -736,7 +895,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -747,7 +906,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -758,7 +917,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -769,7 +928,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -780,7 +939,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -791,7 +950,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -802,7 +961,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -813,7 +972,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -824,7 +983,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -835,67 +994,67 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -906,7 +1065,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -917,99 +1076,99 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1017,127 +1176,121 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1148,7 +1301,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
@@ -1159,39 +1312,51 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requirementDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.requirementDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.satisfiedRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.satisfiedRequirement, "satisfiedRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.satisfiedRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.satisfiedRequirement, "satisfiedRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.satisfyingFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.satisfyingFeature, "satisfyingFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.satisfyingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.satisfyingFeature, "satisfyingFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
@@ -1202,15 +1367,18 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1221,7 +1389,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1232,7 +1400,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1243,7 +1411,7 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1254,13 +1422,13 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1275,18 +1443,11 @@ public override void Write(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, s
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISatisfyRequirementUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SatisfyRequirementUsage");
@@ -1298,18 +1459,53 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1320,7 +1516,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1343,7 +1539,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1353,7 +1549,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1361,7 +1557,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1384,7 +1580,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1397,9 +1593,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1407,7 +1603,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1415,7 +1611,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1423,9 +1627,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1438,7 +1709,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.requirementDefinition != null && poco.requirementDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "requirementDefinition", null, poco.requirementDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.satisfiedRequirement != null && poco.satisfiedRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "satisfiedRequirement", null, poco.satisfiedRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.satisfyingFeature != null && poco.satisfyingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "satisfyingFeature", null, poco.satisfyingFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1446,7 +1749,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -1456,738 +1767,753 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2195,250 +2521,259 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISatisfyRequirementUs
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requirementDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.requirementDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.requirementDefinition, "requirementDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.satisfiedRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.satisfiedRequirement, "satisfiedRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.satisfiedRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.satisfiedRequirement, "satisfiedRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.satisfyingFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.satisfyingFeature, "satisfyingFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.satisfyingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.satisfyingFeature, "satisfyingFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs
index 384afb909..4040d059f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SelectExpressionWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SelectExpressionWriter" /> is to write an instance of <see cref="ISelectExpression" />
@@ -74,17 +75,10 @@ public SelectExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerF
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISelectExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SelectExpression");
@@ -96,6 +90,14 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -106,13 +108,48 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("instantiatedType", poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -123,7 +160,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -146,12 +183,12 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -159,7 +196,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -182,9 +219,9 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -192,7 +229,15 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -200,12 +245,63 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            if (poco.Operator != "select")
+            {
+                if (!string.IsNullOrWhiteSpace(poco.Operator))
+                {
+                    xmlWriter.WriteAttributeString("operator", poco.Operator);
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
-                xmlWriter.WriteAttributeString("operator", poco.Operator);
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -213,7 +309,15 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -223,7 +327,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
@@ -234,7 +338,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -245,15 +349,18 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -264,7 +371,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -275,7 +382,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -286,15 +393,18 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -305,7 +415,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -316,15 +426,18 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -335,15 +448,18 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -354,7 +470,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -365,7 +481,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -376,7 +492,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -387,15 +503,18 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -406,18 +525,18 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -428,15 +547,18 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -447,67 +569,67 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -518,7 +640,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -529,99 +651,99 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -629,111 +751,99 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -744,15 +854,18 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -763,7 +876,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -774,7 +887,7 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -795,18 +908,11 @@ public override void Write(XmlWriter xmlWriter, ISelectExpression poco, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISelectExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SelectExpression");
@@ -818,6 +924,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -828,13 +942,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "instantiatedType", null, poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -845,7 +994,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -868,12 +1017,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -881,7 +1030,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -904,9 +1053,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -914,7 +1063,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -922,12 +1079,63 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
                 }
             }
 
-            if (!string.IsNullOrWhiteSpace(poco.Operator))
+            if (poco.Operator != "select")
+            {
+                if (!string.IsNullOrWhiteSpace(poco.Operator))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "operator", null, poco.Operator);
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -935,7 +1143,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -945,405 +1161,423 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1351,158 +1585,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISelectExpression poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs
index a742c51bb..a559d810b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SendActionUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SendActionUsageWriter" /> is to write an instance of <see cref="ISendActionUsage" />
@@ -98,17 +99,10 @@ public SendActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISendActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SendActionUsage");
@@ -120,6 +114,14 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +132,40 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +176,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +199,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -198,7 +227,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -211,9 +240,9 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -221,7 +250,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -229,7 +258,15 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -237,9 +274,84 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadArgument != null && poco.payloadArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("payloadArgument", poco.payloadArgument.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -247,7 +359,23 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.receiverArgument != null && poco.receiverArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("receiverArgument", poco.receiverArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.senderArgument != null && poco.senderArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("senderArgument", poco.senderArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -257,7 +385,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -268,7 +396,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -279,15 +407,18 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -298,7 +429,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -309,7 +440,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -320,7 +451,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -331,15 +462,18 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -350,7 +484,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -361,15 +495,18 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -380,7 +517,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -391,15 +528,18 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -410,7 +550,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -421,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -432,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -443,18 +583,18 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -465,15 +605,18 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -484,7 +627,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -495,7 +638,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -506,7 +649,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -517,7 +660,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -528,7 +671,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -539,7 +682,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -550,18 +693,18 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -572,7 +715,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -583,7 +726,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -594,7 +737,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -605,7 +748,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -616,7 +759,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -627,7 +770,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -638,7 +781,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -649,7 +792,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -660,7 +803,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -671,7 +814,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -682,7 +825,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -693,7 +836,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -704,7 +847,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -715,7 +858,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -726,7 +869,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -737,7 +880,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -748,7 +891,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -759,7 +902,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -770,7 +913,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -781,7 +924,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -792,67 +935,67 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -863,7 +1006,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -874,99 +1017,99 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -974,127 +1117,121 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1105,31 +1242,40 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.receiverArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.receiverArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.senderArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.senderArgument, "senderArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.senderArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.senderArgument, "senderArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1140,7 +1286,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1151,7 +1297,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1162,7 +1308,7 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1173,13 +1319,13 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1194,18 +1340,11 @@ public override void Write(XmlWriter xmlWriter, ISendActionUsage poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISendActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SendActionUsage");
@@ -1217,6 +1356,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1227,13 +1374,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1244,7 +1418,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1267,7 +1441,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1277,7 +1451,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1295,7 +1469,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1308,9 +1482,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1318,7 +1492,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1326,7 +1500,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1334,9 +1516,84 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadArgument != null && poco.payloadArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "payloadArgument", null, poco.payloadArgument.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1344,7 +1601,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.receiverArgument != null && poco.receiverArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "receiverArgument", null, poco.receiverArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.senderArgument != null && poco.senderArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "senderArgument", null, poco.senderArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1354,716 +1627,731 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2071,212 +2359,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISendActionUsage poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.payloadArgument, "payloadArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.receiverArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.receiverArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.receiverArgument, "receiverArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.senderArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.senderArgument, "senderArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.senderArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.senderArgument, "senderArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs
index 1c8d77470..77e8d151e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SpecializationWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SpecializationWriter" /> is to write an instance of <see cref="ISpecialization" />
@@ -69,17 +70,10 @@ public SpecializationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISpecialization" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISpecialization poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISpecialization poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Specialization");
@@ -106,17 +100,22 @@ public override void Write(XmlWriter xmlWriter, ISpecialization poco, string ele
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.General != null && poco.General.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("general", poco.General.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +123,7 @@ public override void Write(XmlWriter xmlWriter, ISpecialization poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -132,7 +131,23 @@ public override void Write(XmlWriter xmlWriter, ISpecialization poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -140,7 +155,7 @@ public override void Write(XmlWriter xmlWriter, ISpecialization poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -148,9 +163,14 @@ public override void Write(XmlWriter xmlWriter, ISpecialization poco, string ele
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.Specific != null && poco.Specific.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("specific", poco.Specific.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -163,27 +183,30 @@ public override void Write(XmlWriter xmlWriter, ISpecialization poco, string ele
 
             if (poco.General != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.General, "general", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.General.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.General, "general", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -192,7 +215,7 @@ public override void Write(XmlWriter xmlWriter, ISpecialization poco, string ele
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -200,69 +223,52 @@ public override void Write(XmlWriter xmlWriter, ISpecialization poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
             if (poco.Specific != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Specific, "specific", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.Specific.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Specific, "specific", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -283,18 +289,11 @@ public override void Write(XmlWriter xmlWriter, ISpecialization poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISpecialization" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISpecialization poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISpecialization poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Specialization");
@@ -321,17 +320,22 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISpecialization poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.General != null && poco.General.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "general", null, poco.General.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -339,7 +343,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISpecialization poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -347,7 +351,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISpecialization poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -355,7 +375,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISpecialization poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -363,42 +383,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISpecialization poco,
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.Specific != null && poco.Specific.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "specific", null, poco.Specific.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
             if (poco.General != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.General, "general", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.General.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.General, "general", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -407,7 +435,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISpecialization poco,
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -415,75 +443,58 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISpecialization poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
             if (poco.Specific != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.Specific, "specific", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.Specific.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.Specific, "specific", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs
index 6040a2567..89928330f 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StakeholderMembershipWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Parts;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="StakeholderMembershipWriter" /> is to write an instance of <see cref="IStakeholderMembership" />
@@ -74,17 +75,10 @@ public StakeholderMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStakeholderMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StakeholderMembership");
@@ -116,12 +110,12 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -129,7 +123,7 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -137,7 +131,7 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -145,7 +139,7 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -153,7 +147,7 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -161,7 +155,31 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedStakeholderParameter != null && poco.ownedStakeholderParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedStakeholderParameter", poco.ownedStakeholderParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -169,7 +187,7 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -177,11 +195,14 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -192,24 +213,24 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -218,7 +239,7 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -226,72 +247,52 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedStakeholderParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedStakeholderParameter, "ownedStakeholderParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedStakeholderParameter, "ownedStakeholderParameter", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -312,18 +313,11 @@ public override void Write(XmlWriter xmlWriter, IStakeholderMembership poco, str
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStakeholderMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:StakeholderMembership");
@@ -355,12 +349,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembershi
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -368,7 +362,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembershi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -376,7 +370,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembershi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -384,7 +378,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembershi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -392,7 +386,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembershi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -400,7 +394,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembershi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedStakeholderParameter != null && poco.ownedStakeholderParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedStakeholderParameter", null, poco.ownedStakeholderParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -408,7 +426,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembershi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -416,39 +434,42 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembershi
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -457,7 +478,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembershi
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -465,78 +486,58 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStakeholderMembershi
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedStakeholderParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedStakeholderParameter, "ownedStakeholderParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedStakeholderParameter, "ownedStakeholderParameter", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs
index 43acc5795..34bb3a83e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.States;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="StateDefinitionWriter" /> is to write an instance of <see cref="IStateDefinition" />
@@ -94,17 +95,10 @@ public StateDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStateDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StateDefinition");
@@ -126,17 +120,41 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.doAction != null && poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("doAction", poco.doAction.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.entryAction != null && poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("entryAction", poco.entryAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.exitAction != null && poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("exitAction", poco.exitAction.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,7 +162,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -154,7 +172,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -177,7 +195,15 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -185,7 +211,31 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -193,7 +243,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -203,7 +253,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
@@ -214,7 +264,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -225,7 +275,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -236,15 +286,18 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.doAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -255,7 +308,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -266,23 +319,29 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.entryAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.exitAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -293,7 +352,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -304,7 +363,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -315,7 +374,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -326,7 +385,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -337,7 +396,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -348,7 +407,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -359,18 +418,18 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -381,15 +440,18 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -400,7 +462,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -411,7 +473,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -422,7 +484,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -433,18 +495,18 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -455,7 +517,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -466,7 +528,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -477,7 +539,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -488,26 +550,26 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -518,40 +580,40 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -562,7 +624,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -573,7 +635,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -584,18 +646,18 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -606,18 +668,18 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -628,18 +690,18 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -650,29 +712,29 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -683,7 +745,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -694,7 +756,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -705,7 +767,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -716,7 +778,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -731,11 +793,11 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -746,7 +808,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -757,18 +819,18 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -779,18 +841,18 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -801,18 +863,18 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -823,7 +885,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -834,7 +896,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -845,7 +907,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -856,7 +918,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -867,36 +929,29 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -907,7 +962,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.state != null)
                 {
@@ -918,7 +973,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -929,7 +984,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -940,7 +995,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -951,7 +1006,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -962,7 +1017,7 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -973,13 +1028,13 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -994,18 +1049,11 @@ public override void Write(XmlWriter xmlWriter, IStateDefinition poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStateDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:StateDefinition");
@@ -1027,17 +1075,41 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.doAction != null && poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "doAction", null, poco.doAction.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.entryAction != null && poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "entryAction", null, poco.entryAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.exitAction != null && poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "exitAction", null, poco.exitAction.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1045,7 +1117,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1055,7 +1127,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1078,7 +1150,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1086,7 +1166,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1094,7 +1198,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1104,526 +1208,538 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "action", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.doAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.entryAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.exitAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1632,255 +1748,248 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateDefinition poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.state != null)
                 {
                     foreach (var item in poco.state)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "state", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "state", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs
index 8e982a5b0..c29d14092 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateSubactionMembershipWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Systems.States;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="StateSubactionMembershipWriter" /> is to write an instance of <see cref="IStateSubactionMembership" />
@@ -74,23 +75,24 @@ public StateSubactionMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStateSubactionMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StateSubactionMembership");
             xmlWriter.WriteAttributeString("xmi", "id", null, poco.Id.ToString());
 
             // Scalar properties as XML attributes (sorted alphabetically)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.action != null && poco.action.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("action", poco.action.Id.ToString());
+                }
+            }
+
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
@@ -116,12 +118,12 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -129,9 +131,9 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
                 }
             }
 
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString().ToLower());
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -139,7 +141,7 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -147,7 +149,7 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -155,7 +157,7 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -163,7 +165,23 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -171,7 +189,7 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -179,19 +197,22 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.action, "action", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.action, "action", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -202,24 +223,24 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -228,7 +249,7 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -236,64 +257,44 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -314,24 +315,25 @@ public override void Write(XmlWriter xmlWriter, IStateSubactionMembership poco,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStateSubactionMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:StateSubactionMembership");
             await xmlWriter.WriteAttributeStringAsync("xmi", "id", null, poco.Id.ToString());
 
             // Scalar properties as XML attributes (sorted alphabetically)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.action != null && poco.action.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "action", null, poco.action.Id.ToString());
+                }
+            }
+
             if (poco.AliasIds != null && poco.AliasIds.Count > 0)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
@@ -357,12 +359,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMember
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -370,9 +372,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMember
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString().ToLower());
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -380,7 +382,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMember
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -388,7 +390,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMember
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -396,7 +398,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMember
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -404,7 +406,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMember
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -412,7 +430,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMember
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -420,47 +438,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMember
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.action, "action", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.action, "action", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -469,7 +490,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMember
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -477,70 +498,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateSubactionMember
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs
index f22d0129b..b3ac380bc 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StateUsageWriter.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.States;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="StateUsageWriter" /> is to write an instance of <see cref="IStateUsage" />
@@ -97,17 +98,10 @@ public StateUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStateUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IStateUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStateUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:StateUsage");
@@ -119,6 +113,14 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -129,13 +131,64 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.doAction != null && poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("doAction", poco.doAction.Id.ToString());
+                }
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.entryAction != null && poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("entryAction", poco.entryAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.exitAction != null && poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("exitAction", poco.exitAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -146,7 +199,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -169,7 +222,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -179,7 +232,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -202,7 +255,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -215,9 +268,9 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -225,7 +278,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -233,7 +286,15 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -241,9 +302,76 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -251,7 +379,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -261,7 +389,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -272,15 +400,18 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -291,7 +422,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -302,15 +433,18 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.doAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -321,7 +455,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -332,31 +466,40 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.entryAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.exitAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -367,7 +510,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -378,15 +521,18 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -397,7 +543,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -408,15 +554,18 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -427,7 +576,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -438,7 +587,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -449,7 +598,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -460,18 +609,18 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -482,15 +631,18 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -501,7 +653,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -512,7 +664,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -523,7 +675,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -534,7 +686,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -545,7 +697,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -556,7 +708,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -567,18 +719,18 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -589,7 +741,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -600,7 +752,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -611,7 +763,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -622,7 +774,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -633,7 +785,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -644,7 +796,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -655,7 +807,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -666,7 +818,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -677,7 +829,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -688,7 +840,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -699,7 +851,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -710,7 +862,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -721,7 +873,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -732,7 +884,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -743,7 +895,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -754,7 +906,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -765,7 +917,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -776,7 +928,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -787,7 +939,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -798,7 +950,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -809,67 +961,67 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -880,7 +1032,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -891,99 +1043,99 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -991,127 +1143,121 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1122,7 +1268,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stateDefinition != null)
                 {
@@ -1133,7 +1279,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1144,7 +1290,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1155,7 +1301,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1166,7 +1312,7 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1177,13 +1323,13 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1198,18 +1344,11 @@ public override void Write(XmlWriter xmlWriter, IStateUsage poco, string element
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStateUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:StateUsage");
@@ -1221,6 +1360,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1231,13 +1378,64 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.doAction != null && poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "doAction", null, poco.doAction.Id.ToString());
+                }
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.entryAction != null && poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "entryAction", null, poco.entryAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.exitAction != null && poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "exitAction", null, poco.exitAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1248,7 +1446,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1271,7 +1469,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1281,7 +1479,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1304,7 +1502,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1317,9 +1515,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1327,7 +1525,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1335,7 +1533,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1343,9 +1549,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1353,7 +1626,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1363,729 +1636,753 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.doAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.doAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.doAction, "doAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.entryAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.entryAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.entryAction, "entryAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.exitAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.exitAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.exitAction, "exitAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2093,199 +2390,193 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStateUsage poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stateDefinition != null)
                 {
                     foreach (var item in poco.stateDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stateDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "stateDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs
index 760a38175..e74203e90 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StepWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Behaviors;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="StepWriter" /> is to write an instance of <see cref="IStep" />
@@ -72,17 +73,10 @@ public StepWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory logge
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStep" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IStep poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStep poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Step");
@@ -94,6 +88,14 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -104,13 +106,32 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -121,7 +142,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,12 +165,12 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -172,9 +193,9 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -182,7 +203,15 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -190,7 +219,55 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -198,7 +275,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -208,7 +285,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.behavior != null)
                 {
@@ -219,7 +296,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -230,15 +307,18 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -249,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -260,7 +340,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -271,15 +351,18 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -290,7 +373,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -301,15 +384,18 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -320,7 +406,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -331,7 +417,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -342,7 +428,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -353,7 +439,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -364,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -375,18 +461,18 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -397,15 +483,18 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -416,67 +505,67 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -487,7 +576,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -498,99 +587,99 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -598,111 +687,99 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -713,7 +790,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -724,7 +801,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -735,7 +812,7 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -756,18 +833,11 @@ public override void Write(XmlWriter xmlWriter, IStep poco, string elementName,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStep" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Step");
@@ -779,6 +849,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -789,13 +867,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -806,7 +903,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -829,12 +926,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -857,9 +954,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -867,7 +964,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -875,7 +980,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -883,7 +1036,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -893,389 +1046,401 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.behavior != null)
                 {
                     foreach (var item in poco.behavior)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "behavior", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "behavior", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1283,150 +1448,138 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStep poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs
index a9d2bf93e..c36de1d80 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/StructureWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Structures;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="StructureWriter" /> is to write an instance of <see cref="IStructure" />
@@ -73,17 +74,10 @@ public StructureWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStructure" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IStructure poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IStructure poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Structure");
@@ -115,7 +109,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -123,12 +117,12 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -141,7 +135,15 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -149,7 +151,31 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -157,7 +183,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -167,7 +193,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -178,7 +204,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -189,7 +215,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -200,7 +226,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -211,7 +237,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -222,7 +248,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -233,7 +259,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -244,7 +270,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -255,7 +281,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -266,7 +292,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -277,7 +303,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -288,18 +314,18 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -310,15 +336,18 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -329,59 +358,59 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -392,7 +421,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -403,57 +432,57 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -462,73 +491,66 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -539,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -560,18 +582,11 @@ public override void Write(XmlWriter xmlWriter, IStructure poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IStructure" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IStructure poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IStructure poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Structure");
@@ -603,7 +618,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStructure poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -611,12 +626,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStructure poco, stri
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -629,7 +644,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStructure poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -637,7 +660,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -645,7 +692,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStructure poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -655,293 +702,296 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStructure poco, stri
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -950,90 +1000,83 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IStructure poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs
index 411038178..d67b4bdfe 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubclassificationWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SubclassificationWriter" /> is to write an instance of <see cref="ISubclassification" />
@@ -70,17 +71,10 @@ public SubclassificationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISubclassification" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISubclassification poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISubclassification poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Subclassification");
@@ -112,12 +106,12 @@ public override void Write(XmlWriter xmlWriter, ISubclassification poco, string
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -125,7 +119,7 @@ public override void Write(XmlWriter xmlWriter, ISubclassification poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -133,7 +127,23 @@ public override void Write(XmlWriter xmlWriter, ISubclassification poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -141,7 +151,7 @@ public override void Write(XmlWriter xmlWriter, ISubclassification poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -149,9 +159,19 @@ public override void Write(XmlWriter xmlWriter, ISubclassification poco, string
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.Subclassifier != null && poco.Subclassifier.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("subclassifier", poco.Subclassifier.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.Superclassifier != null && poco.Superclassifier.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("superclassifier", poco.Superclassifier.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -162,24 +182,24 @@ public override void Write(XmlWriter xmlWriter, ISubclassification poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -188,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, ISubclassification poco, string
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -196,74 +216,60 @@ public override void Write(XmlWriter xmlWriter, ISubclassification poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningClassifier != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningClassifier, "owningClassifier", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
             if (poco.Subclassifier != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Subclassifier, "subclassifier", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.Subclassifier.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Subclassifier, "subclassifier", elementOriginMap, currentFileUri);
+                }
             }
 
             if (poco.Superclassifier != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Superclassifier, "superclassifier", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.Superclassifier.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.Superclassifier, "superclassifier", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -284,18 +290,11 @@ public override void Write(XmlWriter xmlWriter, ISubclassification poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISubclassification" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISubclassification poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISubclassification poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Subclassification");
@@ -327,12 +326,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubclassification po
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -340,7 +339,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubclassification po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -348,7 +347,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubclassification po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -356,7 +371,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubclassification po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -364,37 +379,47 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubclassification po
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.Subclassifier != null && poco.Subclassifier.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "subclassifier", null, poco.Subclassifier.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.Superclassifier != null && poco.Superclassifier.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "superclassifier", null, poco.Superclassifier.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -403,7 +428,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubclassification po
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -411,80 +436,66 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubclassification po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningClassifier != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningClassifier, "owningClassifier", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
             if (poco.Subclassifier != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.Subclassifier, "subclassifier", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.Subclassifier.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.Subclassifier, "subclassifier", elementOriginMap, currentFileUri);
+                }
             }
 
             if (poco.Superclassifier != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.Superclassifier, "superclassifier", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.Superclassifier.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.Superclassifier, "superclassifier", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs
index 5d2652752..4a7a56e67 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubjectMembershipWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SubjectMembershipWriter" /> is to write an instance of <see cref="ISubjectMembership" />
@@ -74,17 +75,10 @@ public SubjectMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISubjectMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SubjectMembership");
@@ -116,12 +110,12 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -129,7 +123,7 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -137,7 +131,7 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -145,7 +139,7 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -153,7 +147,7 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -161,7 +155,31 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedSubjectParameter != null && poco.ownedSubjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedSubjectParameter", poco.ownedSubjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -169,7 +187,7 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -177,11 +195,14 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -192,24 +213,24 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -218,7 +239,7 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -226,72 +247,52 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedSubjectParameter, "ownedSubjectParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedSubjectParameter, "ownedSubjectParameter", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -312,18 +313,11 @@ public override void Write(XmlWriter xmlWriter, ISubjectMembership poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISubjectMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SubjectMembership");
@@ -355,12 +349,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership po
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -368,7 +362,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -376,7 +370,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -384,7 +378,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -392,7 +386,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -400,7 +394,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedSubjectParameter != null && poco.ownedSubjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedSubjectParameter", null, poco.ownedSubjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -408,7 +426,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -416,39 +434,42 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership po
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -457,7 +478,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership po
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -465,78 +486,58 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubjectMembership po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedSubjectParameter, "ownedSubjectParameter", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedSubjectParameter, "ownedSubjectParameter", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs
index f5f05c3e7..ac745d266 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SubsettingWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SubsettingWriter" /> is to write an instance of <see cref="ISubsetting" />
@@ -70,17 +71,10 @@ public SubsettingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISubsetting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISubsetting poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Subsetting");
@@ -112,12 +106,12 @@ public override void Write(XmlWriter xmlWriter, ISubsetting poco, string element
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -125,7 +119,7 @@ public override void Write(XmlWriter xmlWriter, ISubsetting poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -133,7 +127,23 @@ public override void Write(XmlWriter xmlWriter, ISubsetting poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -141,7 +151,7 @@ public override void Write(XmlWriter xmlWriter, ISubsetting poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -149,9 +159,19 @@ public override void Write(XmlWriter xmlWriter, ISubsetting poco, string element
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.SubsettedFeature != null && poco.SubsettedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("subsettedFeature", poco.SubsettedFeature.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.SubsettingFeature != null && poco.SubsettingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("subsettingFeature", poco.SubsettingFeature.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -162,24 +182,24 @@ public override void Write(XmlWriter xmlWriter, ISubsetting poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -188,7 +208,7 @@ public override void Write(XmlWriter xmlWriter, ISubsetting poco, string element
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -196,74 +216,60 @@ public override void Write(XmlWriter xmlWriter, ISubsetting poco, string element
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeature != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
             if (poco.SubsettedFeature != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.SubsettedFeature, "subsettedFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.SubsettedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.SubsettedFeature, "subsettedFeature", elementOriginMap, currentFileUri);
+                }
             }
 
             if (poco.SubsettingFeature != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.SubsettingFeature, "subsettingFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.SubsettingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.SubsettingFeature, "subsettingFeature", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -284,18 +290,11 @@ public override void Write(XmlWriter xmlWriter, ISubsetting poco, string element
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISubsetting" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISubsetting poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISubsetting poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Subsetting");
@@ -327,12 +326,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubsetting poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -340,7 +339,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubsetting poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -348,7 +347,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubsetting poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -356,7 +371,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubsetting poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -364,37 +379,47 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubsetting poco, str
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.SubsettedFeature != null && poco.SubsettedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "subsettedFeature", null, poco.SubsettedFeature.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.SubsettingFeature != null && poco.SubsettingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "subsettingFeature", null, poco.SubsettingFeature.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -403,7 +428,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubsetting poco, str
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -411,80 +436,66 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISubsetting poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeature != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeature, "owningFeature", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
             if (poco.SubsettedFeature != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.SubsettedFeature, "subsettedFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.SubsettedFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.SubsettedFeature, "subsettedFeature", elementOriginMap, currentFileUri);
+                }
             }
 
             if (poco.SubsettingFeature != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.SubsettingFeature, "subsettingFeature", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.SubsettingFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.SubsettingFeature, "subsettingFeature", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs
index 499caa1ac..2221fa49c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionAsUsageWriter.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Connections;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SuccessionAsUsageWriter" /> is to write an instance of <see cref="ISuccessionAsUsage" />
@@ -96,17 +97,10 @@ public SuccessionAsUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISuccessionAsUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SuccessionAsUsage");
@@ -118,6 +112,14 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -128,13 +130,40 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -145,7 +174,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -173,12 +202,12 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -196,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -209,9 +238,9 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -219,7 +248,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -227,7 +256,15 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -235,7 +272,71 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -243,7 +344,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -251,9 +352,17 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.association != null)
                 {
@@ -264,7 +373,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -275,7 +384,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -286,23 +395,29 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.definition != null)
                 {
@@ -313,7 +428,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -324,7 +439,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -335,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -346,7 +461,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -357,15 +472,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -376,7 +494,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -387,15 +505,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -406,7 +527,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -417,7 +538,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -428,7 +549,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -439,7 +560,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -450,7 +571,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -461,18 +582,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -483,15 +604,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -502,7 +626,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -513,7 +637,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -524,7 +648,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -535,7 +659,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -546,7 +670,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -557,7 +681,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -568,18 +692,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -590,7 +714,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -601,7 +725,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -612,7 +736,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -623,7 +747,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -634,7 +758,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -645,7 +769,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -656,7 +780,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -667,7 +791,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -678,7 +802,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -689,7 +813,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -700,7 +824,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -711,7 +835,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -722,7 +846,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -733,7 +857,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -744,7 +868,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -755,7 +879,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -766,7 +890,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -777,7 +901,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -788,7 +912,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -799,67 +923,67 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -870,7 +994,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -881,99 +1005,99 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -981,7 +1105,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -989,132 +1113,121 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -1125,15 +1238,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -1144,7 +1260,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1155,7 +1271,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1166,7 +1282,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1177,7 +1293,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1188,13 +1304,13 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1209,18 +1325,11 @@ public override void Write(XmlWriter xmlWriter, ISuccessionAsUsage poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISuccessionAsUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SuccessionAsUsage");
@@ -1232,6 +1341,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1242,13 +1359,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1259,7 +1403,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1287,12 +1431,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1310,7 +1454,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1323,9 +1467,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1333,7 +1477,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1341,7 +1485,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1349,7 +1501,71 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1357,7 +1573,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1365,729 +1581,752 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.association != null)
                 {
                     foreach (var item in poco.association)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "association", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.definition != null)
                 {
                     foreach (var item in poco.definition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "definition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2095,7 +2334,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -2103,212 +2342,204 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionAsUsage po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs
index f4761be57..24247196b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowUsageWriter.cs
@@ -70,6 +70,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Flows;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SuccessionFlowUsageWriter" /> is to write an instance of <see cref="ISuccessionFlowUsage" />
@@ -100,17 +101,10 @@ public SuccessionFlowUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISuccessionFlowUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SuccessionFlowUsage");
@@ -122,6 +116,14 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -132,13 +134,48 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -149,7 +186,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -177,7 +214,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -187,7 +224,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -205,7 +242,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -218,9 +255,9 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -228,7 +265,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -236,7 +273,15 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -244,9 +289,84 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadFeature != null && poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("payloadFeature", poco.payloadFeature.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -254,7 +374,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -262,9 +382,33 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceOutputFeature != null && poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceOutputFeature", poco.sourceOutputFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetInputFeature != null && poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("targetInputFeature", poco.targetInputFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -275,7 +419,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -286,7 +430,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -297,23 +441,29 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -324,7 +474,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -335,7 +485,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -346,15 +496,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -365,7 +518,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -376,15 +529,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -395,7 +551,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowDefinition != null)
                 {
@@ -406,7 +562,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowEnd != null)
                 {
@@ -417,7 +573,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -428,15 +584,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -447,7 +606,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -458,7 +617,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -469,7 +628,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -480,18 +639,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -502,15 +661,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -521,7 +683,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -532,7 +694,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -543,7 +705,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -554,7 +716,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -565,7 +727,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -576,7 +738,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -587,18 +749,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -609,7 +771,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -620,7 +782,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -631,7 +793,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -642,7 +804,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -653,7 +815,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -664,7 +826,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -675,7 +837,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -686,7 +848,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -697,7 +859,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -708,7 +870,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -719,7 +881,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -730,7 +892,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -741,7 +903,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -752,7 +914,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -763,7 +925,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -774,7 +936,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -785,7 +947,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -796,7 +958,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -807,7 +969,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -818,7 +980,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -829,67 +991,67 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -900,7 +1062,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -911,99 +1073,99 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1011,7 +1173,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1019,132 +1181,121 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1155,15 +1306,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadType != null)
                 {
@@ -1174,7 +1328,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -1185,23 +1339,29 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceOutputFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -1212,15 +1372,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetInputFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1231,7 +1394,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1242,7 +1405,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1253,7 +1416,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1264,13 +1427,13 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1285,18 +1448,11 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlowUsage poco, strin
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISuccessionFlowUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SuccessionFlowUsage");
@@ -1308,6 +1464,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1318,13 +1482,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1335,7 +1534,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1363,7 +1562,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1373,7 +1572,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1391,7 +1590,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1404,9 +1603,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1414,7 +1613,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1422,7 +1621,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1430,9 +1637,84 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadFeature != null && poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "payloadFeature", null, poco.payloadFeature.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1440,7 +1722,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1448,748 +1730,790 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceOutputFeature != null && poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceOutputFeature", null, poco.sourceOutputFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetInputFeature != null && poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "targetInputFeature", null, poco.targetInputFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowDefinition != null)
                 {
                     foreach (var item in poco.flowDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "flowDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowEnd != null)
                 {
                     foreach (var item in poco.flowEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "flowEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2197,7 +2521,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -2205,258 +2529,259 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlowUsage
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadType != null)
                 {
                     foreach (var item in poco.payloadType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "payloadType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceOutputFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetInputFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs
index cdd1ae4c4..099d50d2c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionFlowWriter.cs
@@ -46,6 +46,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Interactions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SuccessionFlowWriter" /> is to write an instance of <see cref="ISuccessionFlow" />
@@ -76,17 +77,10 @@ public SuccessionFlowWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISuccessionFlow" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:SuccessionFlow");
@@ -98,6 +92,14 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -108,13 +110,40 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -125,7 +154,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -153,12 +182,12 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -181,9 +210,9 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -191,7 +220,15 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -199,7 +236,63 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadFeature != null && poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("payloadFeature", poco.payloadFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -207,7 +300,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -215,9 +308,33 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceOutputFeature != null && poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceOutputFeature", poco.sourceOutputFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetInputFeature != null && poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("targetInputFeature", poco.targetInputFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -228,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -239,23 +356,29 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -266,7 +389,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -277,15 +400,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -296,7 +422,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -307,15 +433,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -326,7 +455,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowEnd != null)
                 {
@@ -337,7 +466,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -348,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -359,7 +488,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -370,7 +499,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -381,7 +510,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.interaction != null)
                 {
@@ -392,7 +521,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -403,18 +532,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -425,15 +554,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -444,67 +576,67 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -515,7 +647,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -526,99 +658,99 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -626,7 +758,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -634,116 +766,99 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -754,15 +869,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadType != null)
                 {
@@ -773,7 +891,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -784,23 +902,29 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceOutputFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -811,15 +935,18 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetInputFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -830,7 +957,7 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -851,18 +978,11 @@ public override void Write(XmlWriter xmlWriter, ISuccessionFlow poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISuccessionFlow" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:SuccessionFlow");
@@ -874,6 +994,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -884,13 +1012,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -901,7 +1056,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -929,12 +1084,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -957,9 +1112,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -967,7 +1122,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -975,7 +1138,63 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.payloadFeature != null && poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "payloadFeature", null, poco.payloadFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -983,7 +1202,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -991,410 +1210,449 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceOutputFeature != null && poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceOutputFeature", null, poco.sourceOutputFeature.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.targetInputFeature != null && poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "targetInputFeature", null, poco.targetInputFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.flowEnd != null)
                 {
                     foreach (var item in poco.flowEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "flowEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "flowEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.interaction != null)
                 {
                     foreach (var item in poco.interaction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "interaction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "interaction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1402,7 +1660,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1410,209 +1668,204 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccessionFlow poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.payloadFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.payloadFeature, "payloadFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.payloadType != null)
                 {
                     foreach (var item in poco.payloadType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "payloadType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "payloadType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceOutputFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceOutputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceOutputFeature, "sourceOutputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetInputFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.targetInputFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.targetInputFeature, "targetInputFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs
index 63aee085b..b19a76a5a 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/SuccessionWriter.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Connectors;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="SuccessionWriter" /> is to write an instance of <see cref="ISuccession" />
@@ -73,17 +74,10 @@ public SuccessionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISuccession" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ISuccession poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ISuccession poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Succession");
@@ -95,6 +89,14 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -105,13 +107,40 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("defaultFeaturingType", poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -122,7 +151,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -150,12 +179,12 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -178,9 +207,9 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -188,7 +217,15 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -196,7 +233,55 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -204,7 +289,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -212,9 +297,17 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("sourceFeature", poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.association != null)
                 {
@@ -225,7 +318,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -236,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
@@ -247,23 +340,29 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -274,7 +373,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -285,7 +384,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -296,15 +395,18 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -315,7 +417,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -326,15 +428,18 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -345,7 +450,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -356,7 +461,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -367,7 +472,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -378,7 +483,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -389,7 +494,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -400,18 +505,18 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -422,15 +527,18 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -441,67 +549,67 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -512,7 +620,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -523,99 +631,99 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -623,7 +731,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -631,116 +739,99 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
@@ -751,15 +842,18 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
@@ -770,7 +864,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -781,7 +875,7 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -802,18 +896,11 @@ public override void Write(XmlWriter xmlWriter, ISuccession poco, string element
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ISuccession" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Succession");
@@ -825,6 +912,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -835,13 +930,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.defaultFeaturingType != null && poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "defaultFeaturingType", null, poco.defaultFeaturingType.Id.ToString());
+                }
+            }
+
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -852,7 +974,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -880,12 +1002,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -908,9 +1030,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -918,7 +1040,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -926,7 +1056,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -934,7 +1112,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -942,410 +1120,433 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.sourceFeature != null && poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "sourceFeature", null, poco.sourceFeature.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.association != null)
                 {
                     foreach (var item in poco.association)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "association", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "association", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.connectorEnd != null)
                 {
                     foreach (var item in poco.connectorEnd)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "connectorEnd", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "connectorEnd", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.defaultFeaturingType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.defaultFeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.defaultFeaturingType, "defaultFeaturingType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1353,7 +1554,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -1361,163 +1562,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ISuccession poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedFeature != null)
                 {
                     foreach (var item in poco.relatedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.sourceFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.sourceFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.sourceFeature, "sourceFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.targetFeature != null)
                 {
                     foreach (var item in poco.targetFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "targetFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "targetFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs
index a9c16acd4..2ed2b07c0 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TerminateActionUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="TerminateActionUsageWriter" /> is to write an instance of <see cref="ITerminateActionUsage" />
@@ -98,17 +99,10 @@ public TerminateActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITerminateActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TerminateActionUsage");
@@ -120,6 +114,14 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +132,40 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +176,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +199,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -198,7 +227,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -211,9 +240,9 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -221,7 +250,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -229,7 +258,15 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -237,9 +274,76 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -247,7 +351,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -255,9 +359,17 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.terminatedOccurrenceArgument != null && poco.terminatedOccurrenceArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("terminatedOccurrenceArgument", poco.terminatedOccurrenceArgument.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -268,7 +380,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -279,15 +391,18 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -298,7 +413,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -309,7 +424,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -320,7 +435,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -331,15 +446,18 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -350,7 +468,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -361,15 +479,18 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -380,7 +501,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -391,15 +512,18 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -410,7 +534,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -421,7 +545,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -432,7 +556,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -443,18 +567,18 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -465,15 +589,18 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -484,7 +611,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -495,7 +622,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -506,7 +633,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -517,7 +644,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -528,7 +655,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -539,7 +666,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -550,18 +677,18 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -572,7 +699,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -583,7 +710,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -594,7 +721,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -605,7 +732,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -616,7 +743,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -627,7 +754,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -638,7 +765,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -649,7 +776,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -660,7 +787,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -671,7 +798,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -682,7 +809,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -693,7 +820,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -704,7 +831,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -715,7 +842,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -726,7 +853,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -737,7 +864,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -748,7 +875,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -759,7 +886,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -770,7 +897,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -781,7 +908,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -792,67 +919,67 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -863,7 +990,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -874,99 +1001,99 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -974,127 +1101,121 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1105,15 +1226,18 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.terminatedOccurrenceArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.terminatedOccurrenceArgument, "terminatedOccurrenceArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.terminatedOccurrenceArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.terminatedOccurrenceArgument, "terminatedOccurrenceArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1124,7 +1248,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1135,7 +1259,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1146,7 +1270,7 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1157,13 +1281,13 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1178,18 +1302,11 @@ public override void Write(XmlWriter xmlWriter, ITerminateActionUsage poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITerminateActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TerminateActionUsage");
@@ -1201,6 +1318,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1211,13 +1336,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1228,7 +1380,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1251,7 +1403,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1261,7 +1413,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1279,7 +1431,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1292,9 +1444,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1302,7 +1454,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1310,7 +1462,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1318,9 +1478,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1328,7 +1555,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1336,718 +1563,741 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.terminatedOccurrenceArgument != null && poco.terminatedOccurrenceArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "terminatedOccurrenceArgument", null, poco.terminatedOccurrenceArgument.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2055,196 +2305,193 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITerminateActionUsage
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.terminatedOccurrenceArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.terminatedOccurrenceArgument, "terminatedOccurrenceArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.terminatedOccurrenceArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.terminatedOccurrenceArgument, "terminatedOccurrenceArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs
index d4a4eda91..dac03ae37 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TextualRepresentationWriter.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="TextualRepresentationWriter" /> is to write an instance of <see cref="ITextualRepresentation" />
@@ -68,17 +69,10 @@ public TextualRepresentationWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITextualRepresentation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TextualRepresentation");
@@ -110,12 +104,12 @@ public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, str
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -128,7 +122,7 @@ public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, str
                 xmlWriter.WriteAttributeString("language", poco.Language);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -136,7 +130,23 @@ public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -144,7 +154,15 @@ public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.representedElement != null && poco.representedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("representedElement", poco.representedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -154,7 +172,7 @@ public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, str
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
@@ -165,7 +183,7 @@ public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -176,35 +194,35 @@ public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -213,56 +231,44 @@ public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.representedElement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.representedElement, "representedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.representedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.representedElement, "representedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -283,18 +289,11 @@ public override void Write(XmlWriter xmlWriter, ITextualRepresentation poco, str
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITextualRepresentation" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ITextualRepresentation poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITextualRepresentation poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TextualRepresentation");
@@ -326,12 +325,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITextualRepresentatio
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -344,7 +343,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITextualRepresentatio
                 await xmlWriter.WriteAttributeStringAsync(null, "language", null, poco.Language);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -352,7 +351,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITextualRepresentatio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -360,7 +375,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITextualRepresentatio
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.representedElement != null && poco.representedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "representedElement", null, poco.representedElement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -370,57 +393,57 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITextualRepresentatio
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.annotation != null)
                 {
                     foreach (var item in poco.annotation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "annotation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "annotation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotatingRelationship != null)
                 {
                     foreach (var item in poco.ownedAnnotatingRelationship)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotatingRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotatingRelationship", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -429,62 +452,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITextualRepresentatio
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningAnnotatingRelationship != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningAnnotatingRelationship, "owningAnnotatingRelationship", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.representedElement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.representedElement, "representedElement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.representedElement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.representedElement, "representedElement", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs
index 861ec7767..8b65f658e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionFeatureMembershipWriter.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.States;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="TransitionFeatureMembershipWriter" /> is to write an instance of <see cref="ITransitionFeatureMembership" />
@@ -74,17 +75,10 @@ public TransitionFeatureMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacad
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITransitionFeatureMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TransitionFeatureMembership");
@@ -116,12 +110,12 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -129,9 +123,9 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
                 }
             }
 
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString().ToLower());
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -139,7 +133,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -147,7 +141,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -155,7 +149,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -163,7 +157,23 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -171,7 +181,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -179,11 +189,22 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.transitionFeature != null && poco.transitionFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("transitionFeature", poco.transitionFeature.Id.ToString());
+                }
+            }
+
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -194,24 +215,24 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -220,7 +241,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -228,64 +249,44 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -296,11 +297,11 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.transitionFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.transitionFeature, "transitionFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.transitionFeature, "transitionFeature", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -314,18 +315,11 @@ public override void Write(XmlWriter xmlWriter, ITransitionFeatureMembership poc
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITransitionFeatureMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TransitionFeatureMembership");
@@ -357,12 +351,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMem
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -370,9 +364,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMem
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString().ToLower());
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -380,7 +374,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -388,7 +382,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -396,7 +390,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -404,7 +398,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -412,7 +422,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -420,39 +430,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMem
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.transitionFeature != null && poco.transitionFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "transitionFeature", null, poco.transitionFeature.Id.ToString());
+                }
+            }
+
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -461,7 +482,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMem
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -469,79 +490,59 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionFeatureMem
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.transitionFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.transitionFeature, "transitionFeature", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.transitionFeature, "transitionFeature", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs
index 08e196320..54929bc44 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TransitionUsageWriter.cs
@@ -69,6 +69,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.States;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="TransitionUsageWriter" /> is to write an instance of <see cref="ITransitionUsage" />
@@ -99,17 +100,10 @@ public TransitionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITransitionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TransitionUsage");
@@ -121,6 +115,14 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -131,13 +133,40 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -148,7 +177,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -171,7 +200,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -181,7 +210,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -199,7 +228,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -212,9 +241,9 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -222,7 +251,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -230,7 +259,15 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -238,9 +275,76 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -248,7 +352,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -256,9 +360,33 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.source != null && poco.source.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("source", poco.source.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.succession != null && poco.succession.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("succession", poco.succession.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.target != null && poco.target.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("target", poco.target.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -269,7 +397,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -280,15 +408,18 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -299,7 +430,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -310,7 +441,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -321,7 +452,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.effectAction != null)
                 {
@@ -332,7 +463,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -343,15 +474,18 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -362,7 +496,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -373,15 +507,18 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -392,7 +529,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.guardExpression != null)
                 {
@@ -403,7 +540,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -414,15 +551,18 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -433,7 +573,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -444,7 +584,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -455,7 +595,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -466,18 +606,18 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -488,15 +628,18 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -507,7 +650,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -518,7 +661,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -529,7 +672,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -540,7 +683,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -551,7 +694,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -562,7 +705,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -573,18 +716,18 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -595,7 +738,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -606,7 +749,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -617,7 +760,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -628,7 +771,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -639,7 +782,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -650,7 +793,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -661,7 +804,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -672,7 +815,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -683,7 +826,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -694,7 +837,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -705,7 +848,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -716,7 +859,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -727,7 +870,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -738,7 +881,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -749,7 +892,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -760,7 +903,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -771,7 +914,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -782,7 +925,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -793,7 +936,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -804,7 +947,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -815,67 +958,67 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -886,7 +1029,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -897,99 +1040,99 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -997,127 +1140,121 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1128,31 +1265,40 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.source != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.source, "source", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.source.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.source, "source", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.succession != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.succession, "succession", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.succession.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.succession, "succession", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.target != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.target, "target", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.target.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.target, "target", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1163,7 +1309,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.triggerAction != null)
                 {
@@ -1174,7 +1320,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1185,7 +1331,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1196,7 +1342,7 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1207,13 +1353,13 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1228,18 +1374,11 @@ public override void Write(XmlWriter xmlWriter, ITransitionUsage poco, string el
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITransitionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TransitionUsage");
@@ -1251,6 +1390,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1261,13 +1408,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1278,7 +1452,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1301,7 +1475,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1311,7 +1485,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1329,7 +1503,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1342,9 +1516,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1352,7 +1526,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1360,7 +1534,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1368,9 +1550,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1378,7 +1627,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1386,740 +1635,779 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.source != null && poco.source.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "source", null, poco.source.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.succession != null && poco.succession.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "succession", null, poco.succession.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.target != null && poco.target.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "target", null, poco.target.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.effectAction != null)
                 {
                     foreach (var item in poco.effectAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "effectAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "effectAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.guardExpression != null)
                 {
                     foreach (var item in poco.guardExpression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "guardExpression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "guardExpression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2127,223 +2415,226 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITransitionUsage poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.source != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.source, "source", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.source.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.source, "source", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.succession != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.succession, "succession", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.succession.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.succession, "succession", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.target != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.target, "target", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.target.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.target, "target", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.triggerAction != null)
                 {
                     foreach (var item in poco.triggerAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "triggerAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "triggerAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs
index 68532eace..3e93e8328 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TriggerInvocationExpressionWriter.cs
@@ -46,6 +46,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="TriggerInvocationExpressionWriter" /> is to write an instance of <see cref="ITriggerInvocationExpression" />
@@ -76,17 +77,10 @@ public TriggerInvocationExpressionWriter(IXmiDataWriterFacade xmiDataWriterFacad
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITriggerInvocationExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TriggerInvocationExpression");
@@ -98,6 +92,14 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -108,13 +110,48 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("function", poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("instantiatedType", poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -125,7 +162,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -148,12 +185,12 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -161,7 +198,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -184,9 +221,9 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariable)
@@ -194,9 +231,17 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 xmlWriter.WriteAttributeString("isVariable", "true");
             }
 
-            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString());
+            xmlWriter.WriteAttributeString("kind", poco.Kind.ToString().ToLower());
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -204,7 +249,55 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -212,7 +305,15 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -222,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
@@ -233,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -244,15 +345,18 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -263,7 +367,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -274,7 +378,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -285,15 +389,18 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -304,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -315,15 +422,18 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -334,15 +444,18 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -353,7 +466,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -364,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -375,7 +488,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -386,15 +499,18 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -405,18 +521,18 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -427,15 +543,18 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -446,67 +565,67 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -517,7 +636,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -528,99 +647,99 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -628,111 +747,99 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -743,15 +850,18 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -762,7 +872,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
@@ -773,7 +883,7 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -794,18 +904,11 @@ public override void Write(XmlWriter xmlWriter, ITriggerInvocationExpression poc
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITriggerInvocationExpression" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExpression poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExpression poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TriggerInvocationExpression");
@@ -817,6 +920,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -827,13 +938,48 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.function != null && poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "function", null, poco.function.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.instantiatedType != null && poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "instantiatedType", null, poco.instantiatedType.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -844,7 +990,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -867,12 +1013,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -880,7 +1026,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -903,9 +1049,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariable)
@@ -913,9 +1059,17 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariable", null, "true");
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString());
+            await xmlWriter.WriteAttributeStringAsync(null, "kind", null, poco.Kind.ToString().ToLower());
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -923,7 +1077,55 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -931,7 +1133,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -941,405 +1151,423 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.argument != null)
                 {
                     foreach (var item in poco.argument)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "argument", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "argument", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.function != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.function, "function", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.function.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.function, "function", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.instantiatedType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.instantiatedType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.instantiatedType, "instantiatedType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1347,158 +1575,149 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITriggerInvocationExp
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.type != null)
                 {
                     foreach (var item in poco.type)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "type", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "type", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs
index 0fc5fdd80..ae34dd44e 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeFeaturingWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="TypeFeaturingWriter" /> is to write an instance of <see cref="ITypeFeaturing" />
@@ -70,17 +71,10 @@ public TypeFeaturingWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFact
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITypeFeaturing" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:TypeFeaturing");
@@ -107,17 +101,27 @@ public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elem
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.FeatureOfType != null && poco.FeatureOfType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("featureOfType", poco.FeatureOfType.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.FeaturingType != null && poco.FeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("featuringType", poco.FeaturingType.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -125,7 +129,7 @@ public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -133,7 +137,23 @@ public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -141,7 +161,7 @@ public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elem
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -151,7 +171,7 @@ public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elem
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -164,32 +184,38 @@ public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elem
 
             if (poco.FeatureOfType != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeatureOfType, "featureOfType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.FeatureOfType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeatureOfType, "featureOfType", elementOriginMap, currentFileUri);
+                }
             }
 
             if (poco.FeaturingType != null)
             {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeaturingType, "featuringType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.FeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.FeaturingType, "featuringType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -198,7 +224,7 @@ public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elem
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -206,64 +232,44 @@ public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elem
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureOfType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureOfType, "owningFeatureOfType", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -284,18 +290,11 @@ public override void Write(XmlWriter xmlWriter, ITypeFeaturing poco, string elem
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="ITypeFeaturing" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, ITypeFeaturing poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, ITypeFeaturing poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:TypeFeaturing");
@@ -322,17 +321,27 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITypeFeaturing poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.FeatureOfType != null && poco.FeatureOfType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "featureOfType", null, poco.FeatureOfType.Id.ToString());
+            }
+
+            if (writerOptions.WriteIdRefAsAttribute && poco.FeaturingType != null && poco.FeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "featuringType", null, poco.FeaturingType.Id.ToString());
+            }
+
             if (poco.IsImplied)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -340,7 +349,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITypeFeaturing poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -348,7 +357,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITypeFeaturing poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -356,7 +381,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITypeFeaturing poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -366,45 +391,51 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITypeFeaturing poco,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
             if (poco.FeatureOfType != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.FeatureOfType, "featureOfType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.FeatureOfType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.FeatureOfType, "featureOfType", elementOriginMap, currentFileUri);
+                }
             }
 
             if (poco.FeaturingType != null)
             {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.FeaturingType, "featuringType", elementOriginMap, currentFileUri);
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.FeaturingType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.FeaturingType, "featuringType", elementOriginMap, currentFileUri);
+                }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -413,7 +444,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITypeFeaturing poco,
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -421,70 +452,50 @@ public override async Task WriteAsync(XmlWriter xmlWriter, ITypeFeaturing poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureOfType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureOfType, "owningFeatureOfType", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs
index ec37464d6..bb876299b 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/TypeWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="TypeWriter" /> is to write an instance of <see cref="IType" />
@@ -70,17 +71,10 @@ public TypeWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory logge
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IType" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IType poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IType poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Type");
@@ -112,7 +106,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -120,12 +114,12 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -138,7 +132,15 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -146,7 +148,31 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -154,7 +180,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -164,7 +190,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -175,7 +201,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -186,7 +212,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -197,7 +223,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -208,7 +234,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -219,7 +245,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -230,7 +256,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -241,7 +267,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -252,7 +278,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -263,7 +289,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -274,7 +300,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -285,18 +311,18 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -307,15 +333,18 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -326,59 +355,59 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -389,7 +418,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -400,57 +429,57 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -459,62 +488,55 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -525,7 +547,7 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -546,18 +568,11 @@ public override void Write(XmlWriter xmlWriter, IType poco, string elementName,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IType" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IType poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IType poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Type");
@@ -589,7 +604,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IType poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -597,12 +612,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IType poco, string el
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -615,7 +630,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IType poco, string el
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -623,7 +646,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IType poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -631,7 +678,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IType poco, string el
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -641,293 +688,296 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IType poco, string el
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -936,79 +986,72 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IType poco, string el
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs
index 98a4b8f6b..0ca98d31c 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UnioningWriter.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="UnioningWriter" /> is to write an instance of <see cref="IUnioning" />
@@ -69,17 +70,10 @@ public UnioningWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory l
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IUnioning" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Unioning");
@@ -111,12 +105,12 @@ public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementNa
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -124,7 +118,7 @@ public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -132,7 +126,23 @@ public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -140,7 +150,7 @@ public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -148,9 +158,14 @@ public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementNa
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.UnioningType != null && poco.UnioningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                xmlWriter.WriteAttributeString("unioningType", poco.UnioningType.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -161,24 +176,24 @@ public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -187,7 +202,7 @@ public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementNa
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -195,56 +210,44 @@ public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementNa
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -255,19 +258,14 @@ public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementNa
                 }
             }
 
-            if (includeDerivedProperties)
+            if (poco.UnioningType != null)
             {
-                if (poco.typeUnioned != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.UnioningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.typeUnioned, "typeUnioned", elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.UnioningType, "unioningType", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (poco.UnioningType != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.UnioningType, "unioningType", elementOriginMap, currentFileUri);
-            }
-
 
             xmlWriter.WriteEndElement();
         }
@@ -278,18 +276,11 @@ public override void Write(XmlWriter xmlWriter, IUnioning poco, string elementNa
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IUnioning" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IUnioning poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IUnioning poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Unioning");
@@ -321,12 +312,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUnioning poco, strin
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -334,7 +325,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUnioning poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -342,7 +333,23 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUnioning poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -350,7 +357,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUnioning poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -358,37 +365,42 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUnioning poco, strin
                 }
             }
 
+            if (writerOptions.WriteIdRefAsAttribute && poco.UnioningType != null && poco.UnioningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "unioningType", null, poco.UnioningType.Id.ToString());
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -397,7 +409,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUnioning poco, strin
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -405,79 +417,62 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUnioning poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (poco.UnioningType != null)
             {
-                if (poco.typeUnioned != null)
+                if (!writerOptions.WriteIdRefAsAttribute || !poco.UnioningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.typeUnioned, "typeUnioned", elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.UnioningType, "unioningType", elementOriginMap, currentFileUri);
                 }
             }
 
-            if (poco.UnioningType != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.UnioningType, "unioningType", elementOriginMap, currentFileUri);
-            }
-
 
             await xmlWriter.WriteEndElementAsync();
         }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs
index 0b92c5ad9..17a62b8b6 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UsageWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="UsageWriter" /> is to write an instance of <see cref="IUsage" />
@@ -94,17 +95,10 @@ public UsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory logg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:Usage");
@@ -116,6 +110,14 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -126,13 +128,32 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -143,7 +164,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -166,12 +187,12 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -189,7 +210,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -202,9 +223,9 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -212,7 +233,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -220,7 +241,15 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -228,7 +257,71 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -236,7 +329,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -246,7 +339,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -257,15 +350,18 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.definition != null)
                 {
@@ -276,7 +372,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -287,7 +383,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -298,7 +394,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -309,7 +405,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -320,7 +416,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -331,15 +427,18 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -350,7 +449,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -361,15 +460,18 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -380,7 +482,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -391,7 +493,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -402,7 +504,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -413,7 +515,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -424,7 +526,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -435,18 +537,18 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -457,15 +559,18 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -476,7 +581,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -487,7 +592,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -498,7 +603,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -509,7 +614,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -520,7 +625,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -531,7 +636,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -542,18 +647,18 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -564,7 +669,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -575,7 +680,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -586,7 +691,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -597,7 +702,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -608,7 +713,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -619,7 +724,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -630,7 +735,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -641,7 +746,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -652,7 +757,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -663,7 +768,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -674,7 +779,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -685,7 +790,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -696,7 +801,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -707,7 +812,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -718,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -729,7 +834,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -740,7 +845,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -751,7 +856,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -762,7 +867,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -773,67 +878,67 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -844,7 +949,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -855,99 +960,99 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -955,127 +1060,121 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1086,7 +1185,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1097,7 +1196,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1108,7 +1207,7 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1119,13 +1218,13 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1140,18 +1239,11 @@ public override void Write(XmlWriter xmlWriter, IUsage poco, string elementName,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:Usage");
@@ -1163,6 +1255,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1173,13 +1273,32 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1190,7 +1309,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1213,12 +1332,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1236,7 +1355,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1249,9 +1368,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1259,7 +1378,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1267,7 +1386,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1275,7 +1402,71 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1283,7 +1474,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1293,708 +1484,720 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.definition != null)
                 {
                     foreach (var item in poco.definition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "definition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "definition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2002,177 +2205,171 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUsage poco, string e
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs
index 9a3326b1c..0f597762a 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseDefinitionWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="UseCaseDefinitionWriter" /> is to write an instance of <see cref="IUseCaseDefinition" />
@@ -95,17 +96,10 @@ public UseCaseDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IUseCaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:UseCaseDefinition");
@@ -137,7 +131,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -145,7 +139,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -155,7 +149,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -163,7 +157,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -181,7 +175,15 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -189,7 +191,39 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("objectiveRequirement", poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +231,15 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -205,9 +247,17 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
@@ -218,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -229,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculation != null)
                 {
@@ -240,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -251,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -262,7 +312,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -273,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -284,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -295,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -306,7 +356,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -317,7 +367,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -328,7 +378,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.includedUseCase != null)
                 {
@@ -339,7 +389,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -350,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -361,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -372,7 +422,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -383,18 +433,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -405,23 +455,29 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -432,7 +488,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -443,7 +499,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -454,7 +510,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -465,18 +521,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -487,7 +543,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -498,7 +554,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -509,7 +565,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -520,26 +576,26 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -550,40 +606,40 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -594,7 +650,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -605,7 +661,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -616,18 +672,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -638,18 +694,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -660,18 +716,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -682,29 +738,29 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -715,7 +771,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -726,7 +782,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -737,7 +793,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -748,7 +804,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -763,11 +819,11 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -778,7 +834,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -789,18 +845,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -811,18 +867,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -833,18 +889,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -855,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -866,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -877,7 +933,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -888,7 +944,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -899,36 +955,29 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -939,15 +988,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -958,15 +1010,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -977,7 +1032,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -988,7 +1043,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -999,7 +1054,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1010,13 +1065,13 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1031,18 +1086,11 @@ public override void Write(XmlWriter xmlWriter, IUseCaseDefinition poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IUseCaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:UseCaseDefinition");
@@ -1074,7 +1122,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition po
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1082,7 +1130,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition po
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1092,7 +1140,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition po
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1100,7 +1148,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1118,7 +1166,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition po
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1126,7 +1182,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "objectiveRequirement", null, poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1134,7 +1222,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1142,556 +1238,570 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition po
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "action", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculation != null)
                 {
                     foreach (var item in poco.calculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "calculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.includedUseCase != null)
                 {
                     foreach (var item in poco.includedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "includedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1700,260 +1810,259 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseDefinition po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs
index dcc5779be..12267c7a2 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/UseCaseUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="UseCaseUsageWriter" /> is to write an instance of <see cref="IUseCaseUsage" />
@@ -98,17 +99,10 @@ public UseCaseUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFacto
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IUseCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:UseCaseUsage");
@@ -120,6 +114,14 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +132,40 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +176,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +199,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -188,7 +217,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -206,7 +235,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -219,9 +248,9 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -229,7 +258,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -237,7 +266,15 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -245,9 +282,84 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("objectiveRequirement", poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -255,7 +367,15 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -263,9 +383,25 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.useCaseDefinition != null && poco.useCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("useCaseDefinition", poco.useCaseDefinition.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -276,7 +412,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -287,7 +423,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -298,15 +434,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -317,7 +456,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -328,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -339,7 +478,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -350,15 +489,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -369,7 +511,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -380,15 +522,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -399,7 +544,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -410,7 +555,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.includedUseCase != null)
                 {
@@ -421,15 +566,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -440,7 +588,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -451,7 +599,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -462,7 +610,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -473,18 +621,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -495,15 +643,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -514,7 +665,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -525,7 +676,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -536,7 +687,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -547,7 +698,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -558,7 +709,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -569,7 +720,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -580,18 +731,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -602,7 +753,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -613,7 +764,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -624,7 +775,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -635,7 +786,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -646,7 +797,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -657,7 +808,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -668,7 +819,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -679,7 +830,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -690,7 +841,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -701,7 +852,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -712,7 +863,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -723,7 +874,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -734,7 +885,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -745,7 +896,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -756,7 +907,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -767,7 +918,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -778,7 +929,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -789,7 +940,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -800,15 +951,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -819,7 +973,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -830,67 +984,67 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -901,7 +1055,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -912,99 +1066,99 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1012,127 +1166,121 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1143,23 +1291,29 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1170,7 +1324,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1181,7 +1335,7 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1192,15 +1346,18 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.useCaseDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.useCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1211,13 +1368,13 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1232,18 +1389,11 @@ public override void Write(XmlWriter xmlWriter, IUseCaseUsage poco, string eleme
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IUseCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:UseCaseUsage");
@@ -1255,6 +1405,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1265,13 +1423,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1282,7 +1467,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1305,7 +1490,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1315,7 +1500,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1323,7 +1508,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1341,7 +1526,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1354,9 +1539,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1364,7 +1549,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1372,7 +1557,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1380,9 +1573,84 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "objectiveRequirement", null, poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1390,7 +1658,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1398,748 +1674,782 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.useCaseDefinition != null && poco.useCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "useCaseDefinition", null, poco.useCaseDefinition.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.includedUseCase != null)
                 {
                     foreach (var item in poco.includedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "includedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "includedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2147,212 +2457,215 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IUseCaseUsage poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.useCaseDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.useCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.useCaseDefinition, "useCaseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs
index 72e29d511..c865c76d0 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VariantMembershipWriter.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="VariantMembershipWriter" /> is to write an instance of <see cref="IVariantMembership" />
@@ -70,17 +71,10 @@ public VariantMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogger
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IVariantMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:VariantMembership");
@@ -112,12 +106,12 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -125,7 +119,7 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -133,7 +127,7 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -141,7 +135,7 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -149,7 +143,7 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -157,7 +151,31 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedVariantUsage != null && poco.ownedVariantUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedVariantUsage", poco.ownedVariantUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -165,7 +183,7 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -173,11 +191,14 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -188,32 +209,24 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.membershipOwningNamespace != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -222,7 +235,7 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -230,64 +243,52 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVariantUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedVariantUsage, "ownedVariantUsage", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedVariantUsage, "ownedVariantUsage", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -308,18 +309,11 @@ public override void Write(XmlWriter xmlWriter, IVariantMembership poco, string
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IVariantMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:VariantMembership");
@@ -351,12 +345,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership po
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -364,7 +358,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -372,7 +366,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -380,7 +374,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -388,7 +382,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -396,7 +390,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedVariantUsage != null && poco.ownedVariantUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedVariantUsage", null, poco.ownedVariantUsage.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -404,7 +422,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership po
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -412,47 +430,42 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership po
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
-            {
-                if (poco.membershipOwningNamespace != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.membershipOwningNamespace, "membershipOwningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -461,7 +474,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership po
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -469,70 +482,58 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVariantMembership po
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVariantUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedVariantUsage, "ownedVariantUsage", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedVariantUsage, "ownedVariantUsage", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs
index 72763f83d..f85e0d0e1 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseDefinitionWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="VerificationCaseDefinitionWriter" /> is to write an instance of <see cref="IVerificationCaseDefinition" />
@@ -95,17 +96,10 @@ public VerificationCaseDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IVerificationCaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:VerificationCaseDefinition");
@@ -137,7 +131,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -145,7 +139,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -155,7 +149,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -163,7 +157,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -181,7 +175,15 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -189,7 +191,39 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("objectiveRequirement", poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +231,15 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -205,9 +247,17 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
@@ -218,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -229,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculation != null)
                 {
@@ -240,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -251,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -262,7 +312,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -273,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -284,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -295,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -306,7 +356,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -317,7 +367,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -328,7 +378,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -339,7 +389,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -350,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -361,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -372,18 +422,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -394,23 +444,29 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -421,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -432,7 +488,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -443,7 +499,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -454,18 +510,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -476,7 +532,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -487,7 +543,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -498,7 +554,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -509,26 +565,26 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -539,40 +595,40 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -583,7 +639,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -594,7 +650,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -605,18 +661,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -627,18 +683,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -649,18 +705,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -671,29 +727,29 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -704,7 +760,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -715,7 +771,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -726,7 +782,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -737,7 +793,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -752,11 +808,11 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -767,7 +823,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -778,18 +834,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -800,18 +856,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -822,18 +878,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -844,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -855,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -866,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -877,7 +933,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -888,36 +944,29 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -928,15 +977,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -947,15 +999,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -966,7 +1021,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -977,7 +1032,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -988,7 +1043,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -999,18 +1054,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.verifiedRequirement != null)
                 {
@@ -1031,18 +1086,11 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseDefinition poco
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IVerificationCaseDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:VerificationCaseDefinition");
@@ -1074,7 +1122,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefi
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1082,7 +1130,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefi
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1092,7 +1140,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefi
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1100,7 +1148,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1118,7 +1166,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefi
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1126,7 +1182,39 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "objectiveRequirement", null, poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1134,7 +1222,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefi
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1142,545 +1238,559 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefi
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.action != null)
                 {
                     foreach (var item in poco.action)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "action", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "action", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.calculation != null)
                 {
                     foreach (var item in poco.calculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "calculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "calculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1689,271 +1799,270 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseDefi
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.verifiedRequirement != null)
                 {
                     foreach (var item in poco.verifiedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "verifiedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "verifiedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs
index 4dac4dec2..0168cddac 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/VerificationCaseUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="VerificationCaseUsageWriter" /> is to write an instance of <see cref="IVerificationCaseUsage" />
@@ -98,17 +99,10 @@ public VerificationCaseUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILo
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IVerificationCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:VerificationCaseUsage");
@@ -120,6 +114,22 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.caseDefinition != null && poco.caseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("caseDefinition", poco.caseDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +140,40 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +184,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +207,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +217,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -188,7 +225,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -206,7 +243,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -219,9 +256,9 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -229,7 +266,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -237,7 +274,15 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -245,9 +290,84 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("objectiveRequirement", poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -255,7 +375,15 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -263,9 +391,25 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.verificationCaseDefinition != null && poco.verificationCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("verificationCaseDefinition", poco.verificationCaseDefinition.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -276,7 +420,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -287,15 +431,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.caseDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.caseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -306,15 +453,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -325,7 +475,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -336,7 +486,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -347,7 +497,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -358,15 +508,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -377,7 +530,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -388,15 +541,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -407,7 +563,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -418,15 +574,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -437,7 +596,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -448,7 +607,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -459,7 +618,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -470,18 +629,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -492,15 +651,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -511,7 +673,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -522,7 +684,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -533,7 +695,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -544,7 +706,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -555,7 +717,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -566,7 +728,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -577,18 +739,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -599,7 +761,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -610,7 +772,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -621,7 +783,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -632,7 +794,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -643,7 +805,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -654,7 +816,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -665,7 +827,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -676,7 +838,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -687,7 +849,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -698,7 +860,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -709,7 +871,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -720,7 +882,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -731,7 +893,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -742,7 +904,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -753,7 +915,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -764,7 +926,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -775,7 +937,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -786,7 +948,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -797,15 +959,18 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -816,7 +981,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -827,67 +992,67 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -898,7 +1063,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -909,99 +1074,99 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1009,127 +1174,121 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1140,23 +1299,29 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1167,7 +1332,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1178,7 +1343,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1189,7 +1354,7 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1200,26 +1365,29 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.verificationCaseDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.verificationCaseDefinition, "verificationCaseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.verificationCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.verificationCaseDefinition, "verificationCaseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.verifiedRequirement != null)
                 {
@@ -1240,18 +1408,11 @@ public override void Write(XmlWriter xmlWriter, IVerificationCaseUsage poco, str
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IVerificationCaseUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:VerificationCaseUsage");
@@ -1263,6 +1424,22 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.caseDefinition != null && poco.caseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "caseDefinition", null, poco.caseDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1273,13 +1450,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1290,7 +1494,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1313,7 +1517,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1323,7 +1527,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1331,7 +1535,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1349,7 +1553,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1362,9 +1566,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1372,7 +1576,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1380,7 +1584,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1388,9 +1600,84 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.objectiveRequirement != null && poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "objectiveRequirement", null, poco.objectiveRequirement.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1398,7 +1685,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1406,745 +1701,782 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.verificationCaseDefinition != null && poco.verificationCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "verificationCaseDefinition", null, poco.verificationCaseDefinition.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.caseDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.caseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.caseDefinition, "caseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.objectiveRequirement != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.objectiveRequirement.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.objectiveRequirement, "objectiveRequirement", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2152,223 +2484,226 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IVerificationCaseUsag
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.verificationCaseDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.verificationCaseDefinition, "verificationCaseDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.verificationCaseDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.verificationCaseDefinition, "verificationCaseDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.verifiedRequirement != null)
                 {
                     foreach (var item in poco.verifiedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "verifiedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "verifiedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs
index 7914c8630..5b1dac9fa 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewDefinitionWriter.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ViewDefinitionWriter" /> is to write an instance of <see cref="IViewDefinition" />
@@ -94,17 +95,10 @@ public ViewDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IViewDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewDefinition");
@@ -136,7 +130,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -144,7 +138,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -154,7 +148,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -172,7 +166,15 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -180,7 +182,31 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -188,7 +214,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -196,9 +222,17 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.viewRendering != null && poco.viewRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("viewRendering", poco.viewRendering.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -209,7 +243,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -220,7 +254,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -231,7 +265,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -242,7 +276,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -253,7 +287,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -264,7 +298,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -275,7 +309,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -286,7 +320,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -297,7 +331,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -308,7 +342,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -319,7 +353,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -330,18 +364,18 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -352,15 +386,18 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -371,7 +408,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -382,7 +419,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -393,7 +430,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -404,18 +441,18 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -426,7 +463,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -437,7 +474,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -448,7 +485,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -459,26 +496,26 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -489,40 +526,40 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -533,7 +570,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -544,7 +581,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -555,18 +592,18 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -577,18 +614,18 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -599,18 +636,18 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -621,29 +658,29 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -654,7 +691,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -665,7 +702,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -676,7 +713,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -687,7 +724,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -702,11 +739,11 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -717,7 +754,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -728,18 +765,18 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -750,18 +787,18 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -772,18 +809,18 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -794,7 +831,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -805,7 +842,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -816,7 +853,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -827,7 +864,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -838,36 +875,29 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.satisfiedViewpoint != null)
                 {
@@ -878,7 +908,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -889,7 +919,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -900,7 +930,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -911,7 +941,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -922,18 +952,18 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.view != null)
                 {
@@ -944,7 +974,7 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewCondition != null)
                 {
@@ -955,11 +985,14 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewRendering != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.viewRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
@@ -973,18 +1006,11 @@ public override void Write(XmlWriter xmlWriter, IViewDefinition poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IViewDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ViewDefinition");
@@ -1016,7 +1042,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1024,7 +1050,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco,
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1034,7 +1060,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1052,7 +1078,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1060,7 +1094,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1068,7 +1126,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1076,504 +1134,515 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco,
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.viewRendering != null && poco.viewRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "viewRendering", null, poco.viewRendering.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1582,264 +1651,260 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewDefinition poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.satisfiedViewpoint != null)
                 {
                     foreach (var item in poco.satisfiedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.view != null)
                 {
                     foreach (var item in poco.view)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "view", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "view", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewCondition != null)
                 {
                     foreach (var item in poco.viewCondition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "viewCondition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "viewCondition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewRendering != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.viewRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs
index 049bd40f8..4004f99a2 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewRenderingMembershipWriter.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ViewRenderingMembershipWriter" /> is to write an instance of <see cref="IViewRenderingMembership" />
@@ -72,17 +73,10 @@ public ViewRenderingMembershipWriter(IXmiDataWriterFacade xmiDataWriterFacade, I
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IViewRenderingMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewRenderingMembership");
@@ -114,12 +108,12 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
                 xmlWriter.WriteAttributeString("isImplied", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -127,7 +121,7 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -135,7 +129,7 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -143,7 +137,7 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -151,7 +145,7 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -159,7 +153,31 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedRendering != null && poco.ownedRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedRendering", poco.ownedRendering.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -167,7 +185,15 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referencedRendering != null && poco.referencedRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("referencedRendering", poco.referencedRendering.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -175,11 +201,14 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
                 }
             }
 
-            xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                xmlWriter.WriteAttributeString("visibility", poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -190,24 +219,24 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -216,7 +245,7 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -224,80 +253,63 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedRendering, "ownedRendering", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedRendering, "ownedRendering", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referencedRendering != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedRendering, "referencedRendering", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referencedRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.referencedRendering, "referencedRendering", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -318,18 +330,11 @@ public override void Write(XmlWriter xmlWriter, IViewRenderingMembership poco, s
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IViewRenderingMembership" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembership poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembership poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ViewRenderingMembership");
@@ -361,12 +366,12 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembers
                 await xmlWriter.WriteAttributeStringAsync(null, "isImplied", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -374,7 +379,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -382,7 +387,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberElementId))
                 {
@@ -390,7 +395,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberName))
                 {
@@ -398,7 +403,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.ownedMemberShortName))
                 {
@@ -406,7 +411,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedRendering != null && poco.ownedRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedRendering", null, poco.ownedRendering.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -414,7 +443,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembers
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.referencedRendering != null && poco.referencedRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "referencedRendering", null, poco.referencedRendering.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -422,39 +459,42 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembers
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString());
+            if (poco.Visibility != VisibilityKind.Public)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "visibility", null, poco.Visibility.ToString().ToLower());
+            }
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
@@ -463,7 +503,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembers
             {
                 foreach (var item in poco.OwnedRelatedElement)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelatedElement", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelatedElement", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
@@ -471,86 +511,69 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewRenderingMembers
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedRendering, "ownedRendering", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedRendering, "ownedRendering", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (poco.OwningRelatedElement != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelatedElement, "owningRelatedElement", elementOriginMap, currentFileUri);
-            }
-
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningType != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.referencedRendering != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.referencedRendering, "referencedRendering", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.referencedRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.referencedRendering, "referencedRendering", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.relatedElement != null)
                 {
                     foreach (var item in poco.relatedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "relatedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "relatedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs
index 1315a2103..041988add 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ViewUsageWriter" /> is to write an instance of <see cref="IViewUsage" />
@@ -98,17 +99,10 @@ public ViewUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IViewUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewUsage");
@@ -120,6 +114,14 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +132,40 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +176,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +199,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +209,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -198,7 +227,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -211,9 +240,9 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -221,7 +250,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -229,7 +258,15 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -237,9 +274,76 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -247,7 +351,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -255,9 +359,25 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.viewDefinition != null && poco.viewDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("viewDefinition", poco.viewDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.viewRendering != null && poco.viewRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("viewRendering", poco.viewRendering.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -268,15 +388,18 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -287,7 +410,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
@@ -298,7 +421,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -309,7 +432,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -320,7 +443,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -331,26 +454,29 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.exposedElement != null)
                 {
                     foreach (var item in poco.exposedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "exposedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "exposedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -361,7 +487,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -372,15 +498,18 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -391,7 +520,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -402,15 +531,18 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -421,7 +553,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -432,7 +564,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -443,7 +575,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -454,7 +586,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
@@ -465,18 +597,18 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -487,15 +619,18 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -506,7 +641,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -517,7 +652,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -528,7 +663,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -539,7 +674,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -550,7 +685,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -561,7 +696,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -572,18 +707,18 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -594,7 +729,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -605,7 +740,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -616,7 +751,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -627,7 +762,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -638,7 +773,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -649,7 +784,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -660,7 +795,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -671,7 +806,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -682,7 +817,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -693,7 +828,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -704,7 +839,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -715,7 +850,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -726,7 +861,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -737,7 +872,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -748,7 +883,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -759,7 +894,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -770,7 +905,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -781,7 +916,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -792,7 +927,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -803,7 +938,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -814,67 +949,67 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -885,7 +1020,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -896,99 +1031,99 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -996,127 +1131,121 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.satisfiedViewpoint != null)
                 {
@@ -1127,7 +1256,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1138,7 +1267,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1149,7 +1278,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1160,7 +1289,7 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1171,18 +1300,18 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewCondition != null)
                 {
@@ -1193,19 +1322,25 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewDefinition, "viewDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.viewDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewDefinition, "viewDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewRendering != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.viewRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
@@ -1219,18 +1354,11 @@ public override void Write(XmlWriter xmlWriter, IViewUsage poco, string elementN
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IViewUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ViewUsage");
@@ -1242,6 +1370,14 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1252,13 +1388,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1269,7 +1432,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1292,7 +1455,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1302,7 +1465,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1320,7 +1483,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1333,9 +1496,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1343,7 +1506,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1351,7 +1514,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1359,9 +1530,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1369,7 +1607,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1377,740 +1615,771 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.viewDefinition != null && poco.viewDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "viewDefinition", null, poco.viewDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.viewRendering != null && poco.viewRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "viewRendering", null, poco.viewRendering.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedFeature != null)
                 {
                     foreach (var item in poco.directedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.exposedElement != null)
                 {
                     foreach (var item in poco.exposedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "exposedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "exposedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.itemDefinition != null)
                 {
                     foreach (var item in poco.itemDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "itemDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "itemDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2118,216 +2387,216 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewUsage poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.satisfiedViewpoint != null)
                 {
                     foreach (var item in poco.satisfiedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "satisfiedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewCondition != null)
                 {
                     foreach (var item in poco.viewCondition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "viewCondition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "viewCondition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.viewDefinition, "viewDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.viewDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.viewDefinition, "viewDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewRendering != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.viewRendering.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.viewRendering, "viewRendering", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs
index 3f761ccf3..9e6c68ae9 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointDefinitionWriter.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ViewpointDefinitionWriter" /> is to write an instance of <see cref="IViewpointDefinition" />
@@ -95,17 +96,10 @@ public ViewpointDefinitionWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILogg
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IViewpointDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewpointDefinition");
@@ -132,7 +126,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 xmlWriter.WriteAttributeString("isAbstract", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -140,7 +134,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -150,7 +144,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -158,7 +152,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -176,7 +170,15 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -184,7 +186,31 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -197,7 +223,15 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 xmlWriter.WriteAttributeString("reqId", poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -205,7 +239,15 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -215,7 +257,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -226,7 +268,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
@@ -237,7 +279,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -248,7 +290,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -259,7 +301,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -270,7 +312,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -281,7 +323,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
@@ -292,7 +334,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -303,7 +345,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -314,7 +356,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
@@ -325,7 +367,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -336,7 +378,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -347,7 +389,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -358,7 +400,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -369,7 +411,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -380,18 +422,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -402,15 +444,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -421,7 +466,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
@@ -432,7 +477,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
@@ -443,7 +488,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
@@ -454,18 +499,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
@@ -476,7 +521,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
@@ -487,7 +532,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
@@ -498,7 +543,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
@@ -509,26 +554,26 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
@@ -539,40 +584,40 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -583,7 +628,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
@@ -594,7 +639,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -605,18 +650,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
@@ -627,18 +672,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
@@ -649,18 +694,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
@@ -671,29 +716,29 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
@@ -704,7 +749,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
@@ -715,7 +760,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
@@ -726,7 +771,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
@@ -737,7 +782,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
@@ -752,11 +797,11 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
@@ -767,7 +812,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
@@ -778,18 +823,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
@@ -800,18 +845,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
@@ -822,18 +867,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
@@ -844,7 +889,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
@@ -855,7 +900,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
@@ -866,7 +911,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
@@ -877,7 +922,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
@@ -888,36 +933,29 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -928,7 +966,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
@@ -939,15 +977,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
@@ -958,7 +999,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
@@ -969,15 +1010,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -988,7 +1032,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -999,7 +1043,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1010,7 +1054,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1021,18 +1065,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewpointStakeholder != null)
                 {
@@ -1053,18 +1097,11 @@ public override void Write(XmlWriter xmlWriter, IViewpointDefinition poco, strin
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IViewpointDefinition" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ViewpointDefinition");
@@ -1091,7 +1128,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1099,7 +1136,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition
                 }
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1109,7 +1146,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1117,7 +1154,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1135,7 +1172,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1143,7 +1188,31 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1156,7 +1225,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition
                 await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1164,7 +1241,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -1174,535 +1259,538 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition
 
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.expression != null)
                 {
                     foreach (var item in poco.expression)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "expression", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "expression", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAction != null)
                 {
                     foreach (var item in poco.ownedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAllocation != null)
                 {
                     foreach (var item in poco.ownedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnalysisCase != null)
                 {
                     foreach (var item in poco.ownedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAttribute != null)
                 {
                     foreach (var item in poco.ownedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCalculation != null)
                 {
                     foreach (var item in poco.ownedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCase != null)
                 {
                     foreach (var item in poco.ownedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConcern != null)
                 {
                     foreach (var item in poco.ownedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConnection != null)
                 {
                     foreach (var item in poco.ownedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConstraint != null)
                 {
                     foreach (var item in poco.ownedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEnumeration != null)
                 {
                     foreach (var item in poco.ownedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFlow != null)
                 {
                     foreach (var item in poco.ownedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedInterface != null)
                 {
                     foreach (var item in poco.ownedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedItem != null)
                 {
                     foreach (var item in poco.ownedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMetadata != null)
                 {
                     foreach (var item in poco.ownedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedOccurrence != null)
                 {
                     foreach (var item in poco.ownedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPart != null)
                 {
                     foreach (var item in poco.ownedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedPort != null)
                 {
                     foreach (var item in poco.ownedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReference != null)
                 {
                     foreach (var item in poco.ownedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
@@ -1711,293 +1799,292 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointDefinition
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRendering != null)
                 {
                     foreach (var item in poco.ownedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRequirement != null)
                 {
                     foreach (var item in poco.ownedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedState != null)
                 {
                     foreach (var item in poco.ownedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubclassification != null)
                 {
                     foreach (var item in poco.ownedSubclassification)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubclassification", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubclassification", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTransition != null)
                 {
                     foreach (var item in poco.ownedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUsage != null)
                 {
                     foreach (var item in poco.ownedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUseCase != null)
                 {
                     foreach (var item in poco.ownedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedVerificationCase != null)
                 {
                     foreach (var item in poco.ownedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedView != null)
                 {
                     foreach (var item in poco.ownedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedViewpoint != null)
                 {
                     foreach (var item in poco.ownedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.step != null)
                 {
                     foreach (var item in poco.step)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "step", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "step", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewpointStakeholder != null)
                 {
                     foreach (var item in poco.viewpointStakeholder)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "viewpointStakeholder", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "viewpointStakeholder", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs
index 57a8d878b..687d6b159 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/ViewpointUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="ViewpointUsageWriter" /> is to write an instance of <see cref="IViewpointUsage" />
@@ -98,17 +99,10 @@ public ViewpointUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFac
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IViewpointUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:ViewpointUsage");
@@ -120,18 +114,53 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -142,7 +171,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -165,7 +194,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -175,7 +204,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -183,7 +212,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -201,7 +230,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -214,9 +243,9 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -224,7 +253,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -232,7 +261,15 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -240,9 +277,76 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -255,7 +359,15 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 xmlWriter.WriteAttributeString("reqId", poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("result", poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -263,7 +375,15 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("subjectParameter", poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -271,9 +391,17 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.viewpointDefinition != null && poco.viewpointDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("viewpointDefinition", poco.viewpointDefinition.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
@@ -284,7 +412,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
@@ -295,7 +423,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -306,15 +434,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -325,7 +456,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -336,7 +467,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -347,7 +478,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -358,15 +489,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -377,7 +511,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -388,15 +522,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -407,7 +544,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
@@ -418,7 +555,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -429,15 +566,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -448,7 +588,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -459,7 +599,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -470,7 +610,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -481,18 +621,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -503,15 +643,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -522,7 +665,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -533,7 +676,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -544,7 +687,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -555,7 +698,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -566,7 +709,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -577,7 +720,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -588,18 +731,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -610,7 +753,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -621,7 +764,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -632,7 +775,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -643,7 +786,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -654,7 +797,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -665,7 +808,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -676,7 +819,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -687,7 +830,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -698,7 +841,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -709,7 +852,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -720,7 +863,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -731,7 +874,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -742,7 +885,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -753,7 +896,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -764,7 +907,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -775,7 +918,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -786,7 +929,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -797,7 +940,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -808,7 +951,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -819,7 +962,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -830,67 +973,67 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -901,7 +1044,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -912,99 +1055,99 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -1012,127 +1155,121 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1143,7 +1280,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
@@ -1154,15 +1291,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
@@ -1173,15 +1313,18 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1192,7 +1335,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1203,7 +1346,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1214,7 +1357,7 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1225,26 +1368,29 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewpointDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewpointDefinition, "viewpointDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.viewpointDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.viewpointDefinition, "viewpointDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewpointStakeholder != null)
                 {
@@ -1265,18 +1411,11 @@ public override void Write(XmlWriter xmlWriter, IViewpointUsage poco, string ele
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IViewpointUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:ViewpointUsage");
@@ -1288,18 +1427,53 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1310,7 +1484,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1333,7 +1507,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1343,7 +1517,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1351,7 +1525,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isModelLevelEvaluable)
                 {
@@ -1369,7 +1543,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1382,9 +1556,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1392,7 +1566,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1400,7 +1574,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1408,9 +1590,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1423,7 +1672,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 await xmlWriter.WriteAttributeStringAsync(null, "reqId", null, poco.ReqId);
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.result != null && poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "result", null, poco.result.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1431,7 +1688,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.subjectParameter != null && poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "subjectParameter", null, poco.subjectParameter.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.text != null && poco.text.Count > 0)
                 {
@@ -1439,740 +1704,763 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.viewpointDefinition != null && poco.viewpointDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "viewpointDefinition", null, poco.viewpointDefinition.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actorParameter != null)
                 {
                     foreach (var item in poco.actorParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actorParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actorParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.assumedConstraint != null)
                 {
                     foreach (var item in poco.assumedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "assumedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "assumedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.framedConcern != null)
                 {
                     foreach (var item in poco.framedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "framedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "framedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2180,245 +2468,248 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IViewpointUsage poco,
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.requiredConstraint != null)
                 {
                     foreach (var item in poco.requiredConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "requiredConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "requiredConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.result != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.result, "result", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.result.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.result, "result", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.stakeholderParameter != null)
                 {
                     foreach (var item in poco.stakeholderParameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "stakeholderParameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "stakeholderParameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.subjectParameter != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.subjectParameter.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.subjectParameter, "subjectParameter", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewpointDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.viewpointDefinition, "viewpointDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.viewpointDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.viewpointDefinition, "viewpointDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.viewpointStakeholder != null)
                 {
                     foreach (var item in poco.viewpointStakeholder)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "viewpointStakeholder", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "viewpointStakeholder", elementOriginMap, currentFileUri);
                     }
                 }
             }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs
index eefe97659..fb9cbe184 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/WhileLoopActionUsageWriter.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Root.Elements;
+    using SysML2.NET.Serializer.Xmi.Extensions;
 
     /// <summary>
     /// The purpose of the <see cref="WhileLoopActionUsageWriter" /> is to write an instance of <see cref="IWhileLoopActionUsage" />
@@ -98,17 +99,10 @@ public WhileLoopActionUsageWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILog
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IWhileLoopActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions" /> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
-        public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             xmlWriter.WriteStartElement(elementName);
             xmlWriter.WriteAttributeString("xsi", "type", null, "sysml:WhileLoopActionUsage");
@@ -120,6 +114,22 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 xmlWriter.WriteAttributeString("aliasIds", string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.bodyAction != null && poco.bodyAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("bodyAction", poco.bodyAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("crossFeature", poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 xmlWriter.WriteAttributeString("declaredName", poco.DeclaredName);
@@ -130,13 +140,40 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 xmlWriter.WriteAttributeString("declaredShortName", poco.DeclaredShortName);
             }
 
-            xmlWriter.WriteAttributeString("direction", poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                xmlWriter.WriteAttributeString("direction", poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 xmlWriter.WriteAttributeString("elementId", poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("endOwningType", poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("featureTarget", poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("individualDefinition", poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 xmlWriter.WriteAttributeString("isAbstract", "true");
@@ -147,7 +184,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isComposite", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -170,7 +207,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isEnd", "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 xmlWriter.WriteAttributeString("isImpliedIncluded", "true");
             }
@@ -180,7 +217,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isIndividual", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -198,7 +235,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isPortion", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -211,9 +248,9 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isSufficient", "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                xmlWriter.WriteAttributeString("isUnique", "true");
+                xmlWriter.WriteAttributeString("isUnique", "false");
             }
 
             if (poco.IsVariation)
@@ -221,7 +258,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 xmlWriter.WriteAttributeString("isVariation", "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -229,7 +266,15 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("multiplicity", poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -237,9 +282,76 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedConjugator", poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedCrossSubsetting", poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("ownedReferenceSubsetting", poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owner", poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningDefinition", poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningNamespace", poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningType", poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("owningUsage", poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                xmlWriter.WriteAttributeString("portionKind", poco.PortionKind.Value.ToString().ToLower());
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -247,7 +359,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -255,9 +367,25 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.untilArgument != null && poco.untilArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("untilArgument", poco.untilArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.whileArgument != null && poco.whileArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    xmlWriter.WriteAttributeString("whileArgument", poco.whileArgument.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
@@ -268,15 +396,18 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.bodyAction != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.bodyAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
@@ -287,15 +418,18 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
@@ -306,7 +440,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
@@ -317,7 +451,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
@@ -328,7 +462,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
@@ -339,15 +473,18 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
@@ -358,7 +495,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
@@ -369,15 +506,18 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
@@ -388,7 +528,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
@@ -399,15 +539,18 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
@@ -418,7 +561,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
@@ -429,7 +572,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
@@ -440,7 +583,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
@@ -451,18 +594,18 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
@@ -473,15 +616,18 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
@@ -492,7 +638,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
@@ -503,7 +649,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
@@ -514,7 +660,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
@@ -525,7 +671,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
@@ -536,7 +682,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
@@ -547,7 +693,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
@@ -558,18 +704,18 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
@@ -580,7 +726,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
@@ -591,7 +737,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
@@ -602,7 +748,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
@@ -613,7 +759,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
@@ -624,7 +770,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
@@ -635,7 +781,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
@@ -646,7 +792,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
@@ -657,7 +803,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
@@ -668,7 +814,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
@@ -679,7 +825,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
@@ -690,7 +836,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
@@ -701,7 +847,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
@@ -712,7 +858,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
@@ -723,7 +869,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
@@ -734,7 +880,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
@@ -745,7 +891,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
@@ -756,7 +902,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
@@ -767,7 +913,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
@@ -778,7 +924,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
@@ -789,7 +935,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
@@ -800,67 +946,67 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
@@ -871,7 +1017,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
@@ -882,99 +1028,99 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -982,127 +1128,121 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
@@ -1113,7 +1253,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
@@ -1124,7 +1264,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
@@ -1135,15 +1275,18 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.untilArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.untilArgument, "untilArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.untilArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.untilArgument, "untilArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
@@ -1154,7 +1297,7 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
@@ -1165,22 +1308,25 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        this.XmiDataWriterFacade.WriteContainedElement(xmlWriter, (IData)item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.whileArgument != null)
                 {
-                    this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.whileArgument, "whileArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.whileArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        this.XmiDataWriterFacade.WriteReferenceElement(xmlWriter, (IData)poco.whileArgument, "whileArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
@@ -1194,18 +1340,11 @@ public override void Write(XmlWriter xmlWriter, IWhileLoopActionUsage poco, stri
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="poco">The <see cref="IWhileLoopActionUsage" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>        
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage poco, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage poco, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
             await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, "sysml:WhileLoopActionUsage");
@@ -1217,6 +1356,22 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "aliasIds", null, string.Join(" ", poco.AliasIds));
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.bodyAction != null && poco.bodyAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "bodyAction", null, poco.bodyAction.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.crossFeature != null && poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "crossFeature", null, poco.crossFeature.Id.ToString());
+                }
+            }
+
             if (!string.IsNullOrWhiteSpace(poco.DeclaredName))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredName", null, poco.DeclaredName);
@@ -1227,13 +1382,40 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "declaredShortName", null, poco.DeclaredShortName);
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.ToString());
+            if (poco.Direction.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "direction", null, poco.Direction.Value.ToString().ToLower());
+            }
 
             if (!string.IsNullOrWhiteSpace(poco.ElementId))
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "elementId", null, poco.ElementId);
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.endOwningType != null && poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "endOwningType", null, poco.endOwningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.featureTarget != null && poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "featureTarget", null, poco.featureTarget.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.individualDefinition != null && poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "individualDefinition", null, poco.individualDefinition.Id.ToString());
+                }
+            }
+
             if (poco.IsAbstract)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isAbstract", null, "true");
@@ -1244,7 +1426,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isComposite", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isConjugated)
                 {
@@ -1267,7 +1449,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isEnd", null, "true");
             }
 
-            if (includesImplied || poco.IsImpliedIncluded)
+            if (writerOptions.IncludeImplied || poco.IsImpliedIncluded)
             {
                 await xmlWriter.WriteAttributeStringAsync(null, "isImpliedIncluded", null, "true");
             }
@@ -1277,7 +1459,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isIndividual", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isLibraryElement)
                 {
@@ -1295,7 +1477,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isPortion", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.isReference)
                 {
@@ -1308,9 +1490,9 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isSufficient", null, "true");
             }
 
-            if (poco.IsUnique)
+            if (!poco.IsUnique)
             {
-                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "true");
+                await xmlWriter.WriteAttributeStringAsync(null, "isUnique", null, "false");
             }
 
             if (poco.IsVariation)
@@ -1318,7 +1500,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 await xmlWriter.WriteAttributeStringAsync(null, "isVariation", null, "true");
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.mayTimeVary)
                 {
@@ -1326,7 +1508,15 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.multiplicity != null && poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "multiplicity", null, poco.multiplicity.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.name))
                 {
@@ -1334,9 +1524,76 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 }
             }
 
-            await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.ToString());
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedConjugator != null && poco.ownedConjugator.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedConjugator", null, poco.ownedConjugator.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedCrossSubsetting != null && poco.ownedCrossSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedCrossSubsetting", null, poco.ownedCrossSubsetting.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.ownedReferenceSubsetting != null && poco.ownedReferenceSubsetting.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "ownedReferenceSubsetting", null, poco.ownedReferenceSubsetting.Id.ToString());
+                }
+            }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owner != null && poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owner", null, poco.owner.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningDefinition != null && poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningDefinition", null, poco.owningDefinition.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningNamespace != null && poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningNamespace", null, poco.owningNamespace.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningType != null && poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningType", null, poco.owningType.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.owningUsage != null && poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "owningUsage", null, poco.owningUsage.Id.ToString());
+                }
+            }
+
+            if (poco.PortionKind.HasValue)
+            {
+                await xmlWriter.WriteAttributeStringAsync(null, "portionKind", null, poco.PortionKind.Value.ToString().ToLower());
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.qualifiedName))
                 {
@@ -1344,7 +1601,7 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (!string.IsNullOrWhiteSpace(poco.shortName))
                 {
@@ -1352,726 +1609,760 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
                 }
             }
 
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.untilArgument != null && poco.untilArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "untilArgument", null, poco.untilArgument.Id.ToString());
+                }
+            }
+
+            if (writerOptions.IncludeDerivedProperties)
+            {
+                if (writerOptions.WriteIdRefAsAttribute && poco.whileArgument != null && poco.whileArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                {
+                    await xmlWriter.WriteAttributeStringAsync(null, "whileArgument", null, poco.whileArgument.Id.ToString());
+                }
+            }
+
 
             // Reference/containment properties as child elements (sorted alphabetically)
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.actionDefinition != null)
                 {
                     foreach (var item in poco.actionDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "actionDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "actionDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.bodyAction != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.bodyAction.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.bodyAction, "bodyAction", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.chainingFeature != null)
                 {
                     foreach (var item in poco.chainingFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "chainingFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "chainingFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.crossFeature != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.crossFeature.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.crossFeature, "crossFeature", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.differencingType != null)
                 {
                     foreach (var item in poco.differencingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "differencingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "differencingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.directedUsage != null)
                 {
                     foreach (var item in poco.directedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "directedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "directedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.documentation != null)
                 {
                     foreach (var item in poco.documentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "documentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "documentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endFeature != null)
                 {
                     foreach (var item in poco.endFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "endFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "endFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.endOwningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.endOwningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.endOwningType, "endOwningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.feature != null)
                 {
                     foreach (var item in poco.feature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "feature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "feature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureMembership != null)
                 {
                     foreach (var item in poco.featureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featureMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featureMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featureTarget != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.featureTarget.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.featureTarget, "featureTarget", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.featuringType != null)
                 {
                     foreach (var item in poco.featuringType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "featuringType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "featuringType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.importedMembership != null)
                 {
                     foreach (var item in poco.importedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "importedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "importedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.individualDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.individualDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.individualDefinition, "individualDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedFeature != null)
                 {
                     foreach (var item in poco.inheritedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.inheritedMembership != null)
                 {
                     foreach (var item in poco.inheritedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "inheritedMembership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "inheritedMembership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.input != null)
                 {
                     foreach (var item in poco.input)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "input", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "input", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.intersectingType != null)
                 {
                     foreach (var item in poco.intersectingType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "intersectingType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "intersectingType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.member != null)
                 {
                     foreach (var item in poco.member)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "member", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "member", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.membership != null)
                 {
                     foreach (var item in poco.membership)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "membership", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "membership", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.multiplicity != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.multiplicity.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.multiplicity, "multiplicity", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAction != null)
                 {
                     foreach (var item in poco.nestedAction)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAction", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAction", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAllocation != null)
                 {
                     foreach (var item in poco.nestedAllocation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAllocation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAllocation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAnalysisCase != null)
                 {
                     foreach (var item in poco.nestedAnalysisCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAnalysisCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedAttribute != null)
                 {
                     foreach (var item in poco.nestedAttribute)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedAttribute", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedAttribute", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCalculation != null)
                 {
                     foreach (var item in poco.nestedCalculation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCalculation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCalculation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedCase != null)
                 {
                     foreach (var item in poco.nestedCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConcern != null)
                 {
                     foreach (var item in poco.nestedConcern)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConcern", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConcern", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConnection != null)
                 {
                     foreach (var item in poco.nestedConnection)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConnection", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConnection", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedConstraint != null)
                 {
                     foreach (var item in poco.nestedConstraint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedConstraint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedConstraint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedEnumeration != null)
                 {
                     foreach (var item in poco.nestedEnumeration)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedEnumeration", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedEnumeration", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedFlow != null)
                 {
                     foreach (var item in poco.nestedFlow)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedFlow", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedFlow", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedInterface != null)
                 {
                     foreach (var item in poco.nestedInterface)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedInterface", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedInterface", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedItem != null)
                 {
                     foreach (var item in poco.nestedItem)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedItem", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedItem", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedMetadata != null)
                 {
                     foreach (var item in poco.nestedMetadata)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedMetadata", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedMetadata", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedOccurrence != null)
                 {
                     foreach (var item in poco.nestedOccurrence)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedOccurrence", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedOccurrence", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPart != null)
                 {
                     foreach (var item in poco.nestedPart)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPart", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPart", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedPort != null)
                 {
                     foreach (var item in poco.nestedPort)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedPort", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedPort", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedReference != null)
                 {
                     foreach (var item in poco.nestedReference)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedReference", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedReference", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRendering != null)
                 {
                     foreach (var item in poco.nestedRendering)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRendering", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRendering", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedRequirement != null)
                 {
                     foreach (var item in poco.nestedRequirement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedRequirement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedRequirement", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedState != null)
                 {
                     foreach (var item in poco.nestedState)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedState", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedState", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedTransition != null)
                 {
                     foreach (var item in poco.nestedTransition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedTransition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedTransition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUsage != null)
                 {
                     foreach (var item in poco.nestedUsage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUsage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUsage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedUseCase != null)
                 {
                     foreach (var item in poco.nestedUseCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedUseCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedUseCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedVerificationCase != null)
                 {
                     foreach (var item in poco.nestedVerificationCase)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedVerificationCase", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedVerificationCase", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedView != null)
                 {
                     foreach (var item in poco.nestedView)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedView", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedView", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.nestedViewpoint != null)
                 {
                     foreach (var item in poco.nestedViewpoint)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "nestedViewpoint", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "nestedViewpoint", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.occurrenceDefinition != null)
                 {
                     foreach (var item in poco.occurrenceDefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "occurrenceDefinition", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "occurrenceDefinition", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.output != null)
                 {
                     foreach (var item in poco.output)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "output", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "output", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedAnnotation != null)
                 {
                     foreach (var item in poco.ownedAnnotation)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedAnnotation", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedAnnotation", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedConjugator != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedConjugator, "ownedConjugator", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedConjugator, "ownedConjugator", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedCrossSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedCrossSubsetting, "ownedCrossSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedCrossSubsetting, "ownedCrossSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDifferencing != null)
                 {
                     foreach (var item in poco.ownedDifferencing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDifferencing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDifferencing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedDisjoining != null)
                 {
                     foreach (var item in poco.ownedDisjoining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedDisjoining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedDisjoining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedElement != null)
                 {
                     foreach (var item in poco.ownedElement)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedElement", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedElement", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedEndFeature != null)
                 {
                     foreach (var item in poco.ownedEndFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedEndFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedEndFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeature != null)
                 {
                     foreach (var item in poco.ownedFeature)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedFeature", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedFeature", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureChaining != null)
                 {
                     foreach (var item in poco.ownedFeatureChaining)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureChaining", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureChaining", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureInverting != null)
                 {
                     foreach (var item in poco.ownedFeatureInverting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureInverting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureInverting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedFeatureMembership != null)
                 {
                     foreach (var item in poco.ownedFeatureMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedFeatureMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedFeatureMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedImport != null)
                 {
                     foreach (var item in poco.ownedImport)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedImport", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedImport", writerOptions, elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedIntersecting != null)
                 {
                     foreach (var item in poco.ownedIntersecting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedIntersecting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedIntersecting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMember != null)
                 {
                     foreach (var item in poco.ownedMember)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "ownedMember", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "ownedMember", elementOriginMap, currentFileUri, true);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedMembership != null)
                 {
                     foreach (var item in poco.ownedMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedRedefinition != null)
                 {
                     foreach (var item in poco.ownedRedefinition)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRedefinition", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRedefinition", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedReferenceSubsetting != null)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, poco.ownedReferenceSubsetting, "ownedReferenceSubsetting", writerOptions, elementOriginMap, currentFileUri);
                 }
             }
 
@@ -2079,205 +2370,205 @@ public override async Task WriteAsync(XmlWriter xmlWriter, IWhileLoopActionUsage
             {
                 foreach (var item in poco.OwnedRelationship)
                 {
-                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedRelationship", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                    await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedRelationship", writerOptions, elementOriginMap, currentFileUri, true);
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSpecialization != null)
                 {
                     foreach (var item in poco.ownedSpecialization)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSpecialization", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSpecialization", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedSubsetting != null)
                 {
                     foreach (var item in poco.ownedSubsetting)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedSubsetting", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedSubsetting", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTypeFeaturing != null)
                 {
                     foreach (var item in poco.ownedTypeFeaturing)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTypeFeaturing", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTypeFeaturing", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedTyping != null)
                 {
                     foreach (var item in poco.ownedTyping)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedTyping", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedTyping", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.ownedUnioning != null)
                 {
                     foreach (var item in poco.ownedUnioning)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "ownedUnioning", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "ownedUnioning", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owner != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owner, "owner", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owner.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owner, "owner", elementOriginMap, currentFileUri, true);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningDefinition != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningFeatureMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningFeatureMembership, "owningFeatureMembership", elementOriginMap, currentFileUri);
-                }
-            }
-
-            if (includeDerivedProperties)
-            {
-                if (poco.owningMembership != null)
-                {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningMembership, "owningMembership", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningDefinition.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningDefinition, "owningDefinition", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningNamespace != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningNamespace.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningNamespace, "owningNamespace", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (poco.OwningRelationship != null)
-            {
-                await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.OwningRelationship, "owningRelationship", elementOriginMap, currentFileUri);
-            }
-
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningType != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningType.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningType, "owningType", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.owningUsage != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.owningUsage.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.owningUsage, "owningUsage", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.parameter != null)
                 {
                     foreach (var item in poco.parameter)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "parameter", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "parameter", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.textualRepresentation != null)
                 {
                     foreach (var item in poco.textualRepresentation)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "textualRepresentation", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "textualRepresentation", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.unioningType != null)
                 {
                     foreach (var item in poco.unioningType)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "unioningType", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "unioningType", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.untilArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.untilArgument, "untilArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.untilArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.untilArgument, "untilArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.usage != null)
                 {
                     foreach (var item in poco.usage)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "usage", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "usage", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variant != null)
                 {
                     foreach (var item in poco.variant)
                     {
-                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)item, "variant", elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, item, "variant", elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.variantMembership != null)
                 {
                     foreach (var item in poco.variantMembership)
                     {
-                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, (IData)item, "variantMembership", includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                        await this.XmiDataWriterFacade.WriteContainedElementAsync(xmlWriter, item, "variantMembership", writerOptions, elementOriginMap, currentFileUri);
                     }
                 }
             }
 
-            if (includeDerivedProperties)
+            if (writerOptions.IncludeDerivedProperties)
             {
                 if (poco.whileArgument != null)
                 {
-                    await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, (IData)poco.whileArgument, "whileArgument", elementOriginMap, currentFileUri);
+                    if (!writerOptions.WriteIdRefAsAttribute || !poco.whileArgument.QueryIsValidIdRef(elementOriginMap, currentFileUri))
+                    {
+                        await this.XmiDataWriterFacade.WriteReferenceElementAsync(xmlWriter, poco.whileArgument, "whileArgument", elementOriginMap, currentFileUri);
+                    }
                 }
             }
 
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
index 4e12c4fc8..68fc0e8db 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
@@ -48,12 +48,12 @@ public class XmiDataWriterFacade : IXmiDataWriterFacade
         /// <summary>
         /// A dictionary that contains actions that write <see cref="IData"/> based on a key that represents the POCO type name
         /// </summary>
-        private readonly Dictionary<string, Action<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri>> writerCache;
+        private readonly Dictionary<string, Action<XmlWriter, IData, string, XmiWriterOptions, IXmiElementOriginMap, Uri>> writerCache;
 
         /// <summary>
         /// A dictionary that contains functions that asynchronously write <see cref="IData"/> based on a key that represents the POCO type name
         /// </summary>
-        private readonly Dictionary<string, Func<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri, Task>> writerAsyncCache;
+        private readonly Dictionary<string, Func<XmlWriter, IData, string, XmiWriterOptions, IXmiElementOriginMap, Uri, Task>> writerAsyncCache;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="XmiDataWriterFacade"/>
@@ -63,1681 +63,1681 @@ public XmiDataWriterFacade(ILoggerFactory loggerFactory)
         {
             this.loggerFactory = loggerFactory;
 
-            this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri>>
+            this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, XmiWriterOptions, IXmiElementOriginMap, Uri>>
             {
-                ["AcceptActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AcceptActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AcceptActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ActionDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ActionDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ActionDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ActorMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ActorMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ActorMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AllocationDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AllocationDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AllocationDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AllocationUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AllocationUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AllocationUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AnalysisCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AnalysisCaseDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AnalysisCaseDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AnalysisCaseUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AnalysisCaseUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AnalysisCaseUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AnnotatingElement"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AnnotatingElement"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AnnotatingElementWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Annotation"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Annotation"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AnnotationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AssertConstraintUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AssertConstraintUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AssertConstraintUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AssignmentActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AssignmentActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AssignmentActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Association"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Association"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AssociationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AssociationStructure"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AssociationStructure"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AssociationStructureWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AttributeDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AttributeDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AttributeDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AttributeUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AttributeUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AttributeUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Behavior"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Behavior"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new BehaviorWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, writerOptions, originMap, uri);
                 },
-                ["BindingConnector"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["BindingConnector"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new BindingConnectorWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, writerOptions, originMap, uri);
                 },
-                ["BindingConnectorAsUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["BindingConnectorAsUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new BindingConnectorAsUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["BooleanExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["BooleanExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new BooleanExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CalculationDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CalculationDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CalculationDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CalculationUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CalculationUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CalculationUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CaseDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CaseDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CaseDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CaseUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CaseUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CaseUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Class"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Class"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ClassWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Classifier"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Classifier"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ClassifierWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CollectExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CollectExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CollectExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Comment"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Comment"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CommentWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConcernDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConcernDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConcernDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConcernUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConcernUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConcernUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConjugatedPortDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConjugatedPortDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConjugatedPortDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConjugatedPortTyping"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConjugatedPortTyping"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConjugatedPortTypingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Conjugation"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Conjugation"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConjugationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConnectionDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConnectionDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConnectionDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConnectionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConnectionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConnectionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Connector"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Connector"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConnectorWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConstraintDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConstraintDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConstraintDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConstraintUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConstraintUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConstraintUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConstructorExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConstructorExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConstructorExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CrossSubsetting"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CrossSubsetting"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CrossSubsettingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, writerOptions, originMap, uri);
                 },
-                ["DataType"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["DataType"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DataTypeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, writerOptions, originMap, uri);
                 },
-                ["DecisionNode"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["DecisionNode"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DecisionNodeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Definition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Definition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Dependency"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Dependency"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DependencyWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Differencing"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Differencing"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DifferencingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Disjoining"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Disjoining"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DisjoiningWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Documentation"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Documentation"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DocumentationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ElementFilterMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ElementFilterMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ElementFilterMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["EndFeatureMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["EndFeatureMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new EndFeatureMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["EnumerationDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["EnumerationDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new EnumerationDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["EnumerationUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["EnumerationUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new EnumerationUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["EventOccurrenceUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["EventOccurrenceUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new EventOccurrenceUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ExhibitStateUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ExhibitStateUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ExhibitStateUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Expression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Expression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Feature"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Feature"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureChainExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureChainExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureChainExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureChaining"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureChaining"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureChainingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureInverting"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureInverting"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureInvertingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureReferenceExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureReferenceExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureReferenceExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureTyping"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureTyping"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureTypingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureValue"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureValue"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureValueWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Flow"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Flow"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FlowWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FlowDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FlowDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FlowDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FlowEnd"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FlowEnd"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FlowEndWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FlowUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FlowUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FlowUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ForkNode"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ForkNode"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ForkNodeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ForLoopActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ForLoopActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ForLoopActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FramedConcernMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FramedConcernMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FramedConcernMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Function"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Function"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FunctionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, writerOptions, originMap, uri);
                 },
-                ["IfActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["IfActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new IfActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["IncludeUseCaseUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["IncludeUseCaseUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new IncludeUseCaseUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["IndexExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["IndexExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new IndexExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Interaction"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Interaction"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new InteractionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, writerOptions, originMap, uri);
                 },
-                ["InterfaceDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["InterfaceDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new InterfaceDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["InterfaceUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["InterfaceUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new InterfaceUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Intersecting"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Intersecting"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new IntersectingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Invariant"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Invariant"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new InvariantWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, writerOptions, originMap, uri);
                 },
-                ["InvocationExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["InvocationExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new InvocationExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ItemDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ItemDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ItemDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ItemUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ItemUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ItemUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["JoinNode"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["JoinNode"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new JoinNodeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LibraryPackage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LibraryPackage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LibraryPackageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralBoolean"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralBoolean"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralBooleanWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralInfinity"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralInfinity"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralInfinityWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralInteger"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralInteger"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralIntegerWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralRational"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralRational"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralRationalWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralString"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralString"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralStringWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Membership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Membership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MembershipExpose"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MembershipExpose"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MembershipExposeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MembershipImport"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MembershipImport"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MembershipImportWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MergeNode"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MergeNode"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MergeNodeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Metaclass"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Metaclass"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MetaclassWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MetadataAccessExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MetadataAccessExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MetadataAccessExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MetadataDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MetadataDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MetadataDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MetadataFeature"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MetadataFeature"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MetadataFeatureWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MetadataUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MetadataUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MetadataUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Multiplicity"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Multiplicity"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MultiplicityWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MultiplicityRange"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MultiplicityRange"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MultiplicityRangeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Namespace"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Namespace"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new NamespaceWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, writerOptions, originMap, uri);
                 },
-                ["NamespaceExpose"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["NamespaceExpose"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new NamespaceExposeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, writerOptions, originMap, uri);
                 },
-                ["NamespaceImport"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["NamespaceImport"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new NamespaceImportWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, writerOptions, originMap, uri);
                 },
-                ["NullExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["NullExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new NullExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ObjectiveMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ObjectiveMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ObjectiveMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["OccurrenceDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["OccurrenceDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new OccurrenceDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["OccurrenceUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["OccurrenceUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new OccurrenceUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["OperatorExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["OperatorExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new OperatorExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["OwningMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["OwningMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new OwningMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Package"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Package"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PackageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ParameterMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ParameterMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ParameterMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PartDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PartDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PartDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PartUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PartUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PartUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PayloadFeature"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PayloadFeature"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PayloadFeatureWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PerformActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PerformActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PerformActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PortConjugation"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PortConjugation"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PortConjugationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PortDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PortDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PortDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PortUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PortUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PortUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Predicate"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Predicate"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PredicateWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Redefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Redefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RedefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ReferenceSubsetting"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ReferenceSubsetting"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ReferenceSubsettingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ReferenceUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ReferenceUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ReferenceUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RenderingDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RenderingDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RenderingDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RenderingUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RenderingUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RenderingUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RequirementConstraintMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RequirementConstraintMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RequirementConstraintMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RequirementDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RequirementDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RequirementDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RequirementUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RequirementUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RequirementUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RequirementVerificationMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RequirementVerificationMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RequirementVerificationMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ResultExpressionMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ResultExpressionMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ResultExpressionMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ReturnParameterMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ReturnParameterMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ReturnParameterMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SatisfyRequirementUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SatisfyRequirementUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SatisfyRequirementUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SelectExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SelectExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SelectExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SendActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SendActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SendActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Specialization"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Specialization"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SpecializationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, writerOptions, originMap, uri);
                 },
-                ["StakeholderMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["StakeholderMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StakeholderMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["StateDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["StateDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StateDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["StateSubactionMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["StateSubactionMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StateSubactionMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["StateUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["StateUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StateUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Step"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Step"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StepWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Structure"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Structure"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StructureWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Subclassification"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Subclassification"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SubclassificationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SubjectMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SubjectMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SubjectMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Subsetting"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Subsetting"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SubsettingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Succession"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Succession"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SuccessionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SuccessionAsUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SuccessionAsUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SuccessionAsUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SuccessionFlow"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SuccessionFlow"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SuccessionFlowWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SuccessionFlowUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SuccessionFlowUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SuccessionFlowUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TerminateActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TerminateActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TerminateActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TextualRepresentation"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TextualRepresentation"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TextualRepresentationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TransitionFeatureMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TransitionFeatureMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TransitionFeatureMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TransitionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TransitionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TransitionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TriggerInvocationExpression"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TriggerInvocationExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TriggerInvocationExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Type"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Type"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TypeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TypeFeaturing"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TypeFeaturing"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TypeFeaturingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Unioning"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Unioning"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new UnioningWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Usage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Usage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new UsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["UseCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["UseCaseDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new UseCaseDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["UseCaseUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["UseCaseUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new UseCaseUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["VariantMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["VariantMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new VariantMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["VerificationCaseDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["VerificationCaseDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new VerificationCaseDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["VerificationCaseUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["VerificationCaseUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new VerificationCaseUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ViewDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ViewDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ViewDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ViewpointDefinition"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ViewpointDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ViewpointDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ViewpointUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ViewpointUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ViewpointUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ViewRenderingMembership"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ViewRenderingMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ViewRenderingMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ViewUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ViewUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ViewUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["WhileLoopActionUsage"] = (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["WhileLoopActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new WhileLoopActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
             };
 
-            this.writerAsyncCache = new Dictionary<string, Func<XmlWriter, IData, string, bool, bool, IXmiElementOriginMap, Uri, Task>>
+            this.writerAsyncCache = new Dictionary<string, Func<XmlWriter, IData, string, XmiWriterOptions, IXmiElementOriginMap, Uri, Task>>
             {
-                ["AcceptActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AcceptActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AcceptActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ActionDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ActionDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ActionDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ActorMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ActorMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ActorMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AllocationDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AllocationDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AllocationDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AllocationUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AllocationUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AllocationUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AnalysisCaseDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AnalysisCaseDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AnalysisCaseDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AnalysisCaseUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AnalysisCaseUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AnalysisCaseUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AnnotatingElement"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AnnotatingElement"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AnnotatingElementWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Annotation"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Annotation"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AnnotationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AssertConstraintUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AssertConstraintUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AssertConstraintUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AssignmentActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AssignmentActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AssignmentActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Association"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Association"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AssociationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AssociationStructure"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AssociationStructure"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AssociationStructureWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AttributeDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AttributeDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AttributeDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["AttributeUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["AttributeUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new AttributeUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Behavior"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Behavior"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new BehaviorWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, writerOptions, originMap, uri);
                 },
-                ["BindingConnector"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["BindingConnector"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new BindingConnectorWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, writerOptions, originMap, uri);
                 },
-                ["BindingConnectorAsUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["BindingConnectorAsUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new BindingConnectorAsUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["BooleanExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["BooleanExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new BooleanExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CalculationDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CalculationDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CalculationDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CalculationUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CalculationUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CalculationUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CaseDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CaseDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CaseDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CaseUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CaseUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CaseUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Class"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Class"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ClassWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Classifier"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Classifier"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ClassifierWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CollectExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CollectExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CollectExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Comment"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Comment"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CommentWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConcernDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConcernDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConcernDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConcernUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConcernUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConcernUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConjugatedPortDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConjugatedPortDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConjugatedPortDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConjugatedPortTyping"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConjugatedPortTyping"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConjugatedPortTypingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Conjugation"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Conjugation"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConjugationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConnectionDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConnectionDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConnectionDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConnectionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConnectionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConnectionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Connector"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Connector"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConnectorWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConstraintDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConstraintDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConstraintDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConstraintUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConstraintUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConstraintUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ConstructorExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ConstructorExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ConstructorExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["CrossSubsetting"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["CrossSubsetting"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new CrossSubsettingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, writerOptions, originMap, uri);
                 },
-                ["DataType"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["DataType"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DataTypeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, writerOptions, originMap, uri);
                 },
-                ["DecisionNode"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["DecisionNode"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DecisionNodeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Definition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Definition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Dependency"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Dependency"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DependencyWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Differencing"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Differencing"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DifferencingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Disjoining"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Disjoining"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DisjoiningWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Documentation"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Documentation"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new DocumentationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ElementFilterMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ElementFilterMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ElementFilterMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["EndFeatureMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["EndFeatureMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new EndFeatureMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["EnumerationDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["EnumerationDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new EnumerationDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["EnumerationUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["EnumerationUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new EnumerationUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["EventOccurrenceUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["EventOccurrenceUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new EventOccurrenceUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ExhibitStateUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ExhibitStateUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ExhibitStateUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Expression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Expression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Feature"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Feature"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureChainExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureChainExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureChainExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureChaining"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureChaining"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureChainingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureInverting"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureInverting"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureInvertingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureReferenceExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureReferenceExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureReferenceExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureTyping"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureTyping"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureTypingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FeatureValue"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FeatureValue"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FeatureValueWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Flow"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Flow"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FlowWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FlowDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FlowDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FlowDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FlowEnd"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FlowEnd"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FlowEndWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FlowUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FlowUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FlowUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ForkNode"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ForkNode"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ForkNodeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ForLoopActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ForLoopActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ForLoopActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["FramedConcernMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["FramedConcernMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FramedConcernMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Function"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Function"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new FunctionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, writerOptions, originMap, uri);
                 },
-                ["IfActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["IfActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new IfActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["IncludeUseCaseUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["IncludeUseCaseUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new IncludeUseCaseUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["IndexExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["IndexExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new IndexExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Interaction"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Interaction"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new InteractionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, writerOptions, originMap, uri);
                 },
-                ["InterfaceDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["InterfaceDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new InterfaceDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["InterfaceUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["InterfaceUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new InterfaceUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Intersecting"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Intersecting"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new IntersectingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Invariant"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Invariant"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new InvariantWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, writerOptions, originMap, uri);
                 },
-                ["InvocationExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["InvocationExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new InvocationExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ItemDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ItemDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ItemDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ItemUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ItemUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ItemUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["JoinNode"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["JoinNode"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new JoinNodeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LibraryPackage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LibraryPackage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LibraryPackageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralBoolean"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralBoolean"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralBooleanWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralInfinity"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralInfinity"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralInfinityWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralInteger"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralInteger"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralIntegerWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralRational"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralRational"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralRationalWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, writerOptions, originMap, uri);
                 },
-                ["LiteralString"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["LiteralString"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new LiteralStringWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Membership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Membership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MembershipExpose"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MembershipExpose"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MembershipExposeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MembershipImport"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MembershipImport"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MembershipImportWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MergeNode"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MergeNode"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MergeNodeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Metaclass"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Metaclass"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MetaclassWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MetadataAccessExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MetadataAccessExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MetadataAccessExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MetadataDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MetadataDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MetadataDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MetadataFeature"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MetadataFeature"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MetadataFeatureWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MetadataUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MetadataUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MetadataUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Multiplicity"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Multiplicity"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MultiplicityWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, writerOptions, originMap, uri);
                 },
-                ["MultiplicityRange"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["MultiplicityRange"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new MultiplicityRangeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Namespace"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Namespace"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new NamespaceWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, writerOptions, originMap, uri);
                 },
-                ["NamespaceExpose"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["NamespaceExpose"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new NamespaceExposeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, writerOptions, originMap, uri);
                 },
-                ["NamespaceImport"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["NamespaceImport"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new NamespaceImportWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, writerOptions, originMap, uri);
                 },
-                ["NullExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["NullExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new NullExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ObjectiveMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ObjectiveMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ObjectiveMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["OccurrenceDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["OccurrenceDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new OccurrenceDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["OccurrenceUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["OccurrenceUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new OccurrenceUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["OperatorExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["OperatorExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new OperatorExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["OwningMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["OwningMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new OwningMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Package"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Package"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PackageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ParameterMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ParameterMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ParameterMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PartDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PartDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PartDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PartUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PartUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PartUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PayloadFeature"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PayloadFeature"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PayloadFeatureWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PerformActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PerformActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PerformActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PortConjugation"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PortConjugation"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PortConjugationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PortDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PortDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PortDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["PortUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["PortUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PortUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Predicate"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Predicate"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new PredicateWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Redefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Redefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RedefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ReferenceSubsetting"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ReferenceSubsetting"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ReferenceSubsettingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ReferenceUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ReferenceUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ReferenceUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RenderingDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RenderingDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RenderingDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RenderingUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RenderingUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RenderingUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RequirementConstraintMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RequirementConstraintMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RequirementConstraintMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RequirementDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RequirementDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RequirementDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RequirementUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RequirementUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RequirementUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["RequirementVerificationMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["RequirementVerificationMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new RequirementVerificationMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ResultExpressionMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ResultExpressionMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ResultExpressionMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ReturnParameterMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ReturnParameterMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ReturnParameterMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SatisfyRequirementUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SatisfyRequirementUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SatisfyRequirementUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SelectExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SelectExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SelectExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SendActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SendActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SendActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Specialization"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Specialization"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SpecializationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, writerOptions, originMap, uri);
                 },
-                ["StakeholderMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["StakeholderMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StakeholderMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["StateDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["StateDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StateDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["StateSubactionMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["StateSubactionMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StateSubactionMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["StateUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["StateUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StateUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Step"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Step"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StepWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Structure"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Structure"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new StructureWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Subclassification"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Subclassification"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SubclassificationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SubjectMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SubjectMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SubjectMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Subsetting"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Subsetting"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SubsettingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Succession"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Succession"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SuccessionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SuccessionAsUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SuccessionAsUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SuccessionAsUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SuccessionFlow"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SuccessionFlow"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SuccessionFlowWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, writerOptions, originMap, uri);
                 },
-                ["SuccessionFlowUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["SuccessionFlowUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new SuccessionFlowUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TerminateActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TerminateActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TerminateActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TextualRepresentation"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TextualRepresentation"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TextualRepresentationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TransitionFeatureMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TransitionFeatureMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TransitionFeatureMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TransitionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TransitionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TransitionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TriggerInvocationExpression"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TriggerInvocationExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TriggerInvocationExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Type"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Type"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TypeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, writerOptions, originMap, uri);
                 },
-                ["TypeFeaturing"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["TypeFeaturing"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new TypeFeaturingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Unioning"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Unioning"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new UnioningWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, writerOptions, originMap, uri);
                 },
-                ["Usage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["Usage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new UsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["UseCaseDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["UseCaseDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new UseCaseDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["UseCaseUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["UseCaseUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new UseCaseUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["VariantMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["VariantMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new VariantMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["VerificationCaseDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["VerificationCaseDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new VerificationCaseDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["VerificationCaseUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["VerificationCaseUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new VerificationCaseUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ViewDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ViewDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ViewDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ViewpointDefinition"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ViewpointDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ViewpointDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ViewpointUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ViewpointUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ViewpointUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ViewRenderingMembership"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ViewRenderingMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ViewRenderingMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, writerOptions, originMap, uri);
                 },
-                ["ViewUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["ViewUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new ViewUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, writerOptions, originMap, uri);
                 },
-                ["WhileLoopActionUsage"] = async (xmlWriter, data, elementName, includeDerived, includesImplied, originMap, uri) =>
+                ["WhileLoopActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
                     var writer = new WhileLoopActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, includeDerived, includesImplied, originMap, uri);
+                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
             };
         }
@@ -1748,16 +1748,16 @@ public XmiDataWriterFacade(ILoggerFactory loggerFactory)
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="data">The <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public void Write(XmlWriter xmlWriter, IData data, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             var typeName = data.GetType().Name;
 
             if (this.writerCache.TryGetValue(typeName, out var writer))
             {
-                writer(xmlWriter, data, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                writer(xmlWriter, data, elementName, writerOptions, elementOriginMap, currentFileUri);
             }
             else
             {
@@ -1771,12 +1771,13 @@ public void Write(XmlWriter xmlWriter, IData data, string elementName, bool incl
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="childData">The child <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false)
         {
-            if (!includesImplied && childData is IRelationship rel && rel.IsImplied)
+            if (!writerOptions.IncludeImplied && childData is IRelationship rel && rel.IsImplied)
             {
                 return;
             }
@@ -1787,12 +1788,12 @@ public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string e
 
                 if (childSourceFile != null && childSourceFile != currentFileUri)
                 {
-                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri, shouldSpecifyType);
                     return;
                 }
             }
 
-            this.Write(xmlWriter, childData, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+            this.Write(xmlWriter, childData, elementName, writerOptions, elementOriginMap, currentFileUri);
         }
 
         /// <summary>
@@ -1803,7 +1804,8 @@ public void WriteContainedElement(XmlWriter xmlWriter, IData childData, string e
         /// <param name="elementName">The XML element name to use</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        public void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false)
         {
             if (elementOriginMap != null && currentFileUri != null)
             {
@@ -1811,7 +1813,7 @@ public void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string e
 
                 if (childSourceFile != null && childSourceFile != currentFileUri)
                 {
-                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    WriteHrefElement(xmlWriter, childData, elementName, childSourceFile, currentFileUri, shouldSpecifyType);
                     return;
                 }
             }
@@ -1827,16 +1829,16 @@ public void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string e
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="data">The <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public async Task WriteAsync(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
+        public async Task WriteAsync(XmlWriter xmlWriter, IData data, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null)
         {
             var typeName = data.GetType().Name;
 
             if (this.writerAsyncCache.TryGetValue(typeName, out var writer))
             {
-                await writer(xmlWriter, data, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+                await writer(xmlWriter, data, elementName, writerOptions, elementOriginMap, currentFileUri);
             }
             else
             {
@@ -1850,12 +1852,13 @@ public async Task WriteAsync(XmlWriter xmlWriter, IData data, string elementName
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="childData">The child <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public async Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        public async Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childData, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false)
         {
-            if (!includesImplied && childData is IRelationship rel && rel.IsImplied)
+            if (!writerOptions.IncludeImplied && childData is IRelationship rel && rel.IsImplied)
             {
                 return;
             }
@@ -1866,12 +1869,12 @@ public async Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childDat
 
                 if (childSourceFile != null && childSourceFile != currentFileUri)
                 {
-                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri, shouldSpecifyType);
                     return;
                 }
             }
 
-            await this.WriteAsync(xmlWriter, childData, elementName, includeDerivedProperties, includesImplied, elementOriginMap, currentFileUri);
+            await this.WriteAsync(xmlWriter, childData, elementName, writerOptions, elementOriginMap, currentFileUri);
         }
 
         /// <summary>
@@ -1882,7 +1885,8 @@ public async Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childDat
         /// <param name="elementName">The XML element name to use</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        public async Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri)
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        public async Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false)
         {
             if (elementOriginMap != null && currentFileUri != null)
             {
@@ -1890,7 +1894,7 @@ public async Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childDat
 
                 if (childSourceFile != null && childSourceFile != currentFileUri)
                 {
-                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri);
+                    await WriteHrefElementAsync(xmlWriter, childData, elementName, childSourceFile, currentFileUri, shouldSpecifyType);
                     return;
                 }
             }
@@ -1903,12 +1907,18 @@ public async Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childDat
         /// <summary>
         /// Writes an href element for cross-file references
         /// </summary>
-        private static void WriteHrefElement(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile)
+        private static void WriteHrefElement(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile, bool shouldSpecifyType)
         {
             var relativePath = currentFile.MakeRelativeUri(targetFile);
             var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{childData.Id}";
 
             xmlWriter.WriteStartElement(elementName);
+
+            if (shouldSpecifyType)
+            {
+                xmlWriter.WriteAttributeString("xsi", "type", null, $"sysml:{childData.GetType().Name}");
+            }
+
             xmlWriter.WriteAttributeString("href", href);
             xmlWriter.WriteEndElement();
         }
@@ -1916,12 +1926,18 @@ private static void WriteHrefElement(XmlWriter xmlWriter, IData childData, strin
         /// <summary>
         /// Asynchronously writes an href element for cross-file references
         /// </summary>
-        private static async Task WriteHrefElementAsync(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile)
+        private static async Task WriteHrefElementAsync(XmlWriter xmlWriter, IData childData, string elementName, Uri targetFile, Uri currentFile, bool shouldSpecifyType)
         {
             var relativePath = currentFile.MakeRelativeUri(targetFile);
             var href = $"{Uri.UnescapeDataString(relativePath.ToString())}#{childData.Id}";
 
             await xmlWriter.WriteStartElementAsync(null, elementName, null);
+
+            if (shouldSpecifyType)
+            {
+                await xmlWriter.WriteAttributeStringAsync("xsi", "type", null, $"sysml:{childData.GetType().Name}");
+            }
+
             await xmlWriter.WriteAttributeStringAsync(null, "href", null, href);
             await xmlWriter.WriteEndElementAsync();
         }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs b/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs
index eadc840b3..8ba7c0672 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/IXmiDataWriterFacade.cs
@@ -38,11 +38,10 @@ public interface IXmiDataWriterFacade
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="data">The <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">Whether implied relationships and isImpliedIncluded attributes are serialized</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        void Write(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null);
+        void Write(XmlWriter xmlWriter, IData data, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null);
 
         /// <summary>
         /// Writes a contained child element, checking origin map for cross-file href
@@ -50,11 +49,11 @@ public interface IXmiDataWriterFacade
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="childData">The child <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">Whether implied relationships and isImpliedIncluded attributes are serialized</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        void WriteContainedElement(XmlWriter xmlWriter, IData childData, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false);
 
         /// <summary>
         /// Writes a reference child element, checking origin map for cross-file href
@@ -64,7 +63,8 @@ public interface IXmiDataWriterFacade
         /// <param name="elementName">The XML element name to use</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        void WriteReferenceElement(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false);
 
         /// <summary>
         /// Asynchronously writes the specified <see cref="IData"/> as an XMI element by dispatching to the appropriate per-type writer
@@ -72,11 +72,10 @@ public interface IXmiDataWriterFacade
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="data">The <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">Whether implied relationships and isImpliedIncluded attributes are serialized</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        Task WriteAsync(XmlWriter xmlWriter, IData data, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null);
+        Task WriteAsync(XmlWriter xmlWriter, IData data, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null, Uri currentFileUri = null);
 
         /// <summary>
         /// Asynchronously writes a contained child element, checking origin map for cross-file href
@@ -84,11 +83,11 @@ public interface IXmiDataWriterFacade
         /// <param name="xmlWriter">The target <see cref="XmlWriter"/></param>
         /// <param name="childData">The child <see cref="IData"/> to write</param>
         /// <param name="elementName">The XML element name to use</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">Whether implied relationships and isImpliedIncluded attributes are serialized</param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childData, string elementName, bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        Task WriteContainedElementAsync(XmlWriter xmlWriter, IData childData, string elementName, XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false);
 
         /// <summary>
         /// Asynchronously writes a reference child element, checking origin map for cross-file href
@@ -98,6 +97,7 @@ public interface IXmiDataWriterFacade
         /// <param name="elementName">The XML element name to use</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> for href reconstruction</param>
         /// <param name="currentFileUri">The <see cref="Uri"/> of the current output file for relative href computation</param>
-        Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri);
+        /// <param name="shouldSpecifyType">Asserts that the XSI type should be specified in case of HREF</param>
+        Task WriteReferenceElementAsync(XmlWriter xmlWriter, IData childData, string elementName, IXmiElementOriginMap elementOriginMap, Uri currentFileUri, bool shouldSpecifyType = false);
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/XmiDataWriter.cs b/SysML2.NET.Serializer.Xmi/Writers/XmiDataWriter.cs
index f38922fb2..95ed58a52 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/XmiDataWriter.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/XmiDataWriter.cs
@@ -63,18 +63,11 @@ protected XmiDataWriter(IXmiDataWriterFacade xmiDataWriterFacade, ILoggerFactory
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="data">The <typeparamref name="TData" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         public abstract void Write(XmlWriter xmlWriter, TData data, string elementName,
-            bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null,
+            XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null,
             Uri currentFileUri = null);
 
         /// <summary>
@@ -83,19 +76,12 @@ public abstract void Write(XmlWriter xmlWriter, TData data, string elementName,
         /// <param name="xmlWriter">The target <see cref="XmlWriter" /></param>
         /// <param name="data">The <typeparamref name="TData" /> to write</param>
         /// <param name="elementName">The XML element name</param>
-        /// <param name="includeDerivedProperties">Whether to include derived properties</param>
-        /// <param name="includesImplied">
-        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
-        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
-        /// attribute is written as "true". When <c>false</c>, implied relationships (where
-        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
-        /// and no element's isImpliedIncluded attribute is written.
-        /// </param>
+        /// <param name="writerOptions">The <see cref="XmiWriterOptions"/> instance that provides writer output configuration</param>
         /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> for href reconstruction</param>
         /// <param name="currentFileUri">The optional <see cref="Uri" /> of the current output file</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
         public abstract Task WriteAsync(XmlWriter xmlWriter, TData data, string elementName,
-            bool includeDerivedProperties, bool includesImplied, IXmiElementOriginMap elementOriginMap = null,
+            XmiWriterOptions writerOptions, IXmiElementOriginMap elementOriginMap = null,
             Uri currentFileUri = null);
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/XmiWriterOptions.cs b/SysML2.NET.Serializer.Xmi/Writers/XmiWriterOptions.cs
new file mode 100644
index 000000000..4c7ccd00e
--- /dev/null
+++ b/SysML2.NET.Serializer.Xmi/Writers/XmiWriterOptions.cs
@@ -0,0 +1,49 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="XmiWriterOptions.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2026 Starion Group S.A.
+// 
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+// 
+//        http://www.apache.org/licenses/LICENSE-2.0
+// 
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// 
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Serializer.Xmi.Writers
+{
+    /// <summary>
+    /// The <see cref="XmiWriterOptions"/> provides centralized option provided to <see cref="XmiDataWriter{TData}"/> to customize output format
+    /// </summary>
+    public class XmiWriterOptions
+    {
+        /// <summary>
+        /// Asserts if derived properties have to be included or not.
+        /// </summary>
+        public bool IncludeDerivedProperties { get; set; }
+
+        /// <summary>
+        /// Asserts if implied properties have to be included or not.
+        /// The project-level includesImplied flag as defined in KerML Clause 10, Note 5.
+        /// When <c>true</c>, all implied relationships are serialized and every element's isImpliedIncluded
+        /// attribute is written as "true". When <c>false</c>, implied relationships (where
+        /// <see cref="SysML2.NET.Core.POCO.Root.Elements.IRelationship.IsImplied"/> is true) are excluded
+        /// and no element's isImpliedIncluded attribute is written.
+        /// </summary>
+        public bool IncludeImplied { get; set; }
+
+        /// <summary>
+        /// Asserts if Id Reference values have to be written as attribute, when applicable.
+        /// Default value is <c>true</c>
+        /// </summary>
+        public bool WriteIdRefAsAttribute { get; set; } = true;
+    }
+}

From f05a5b75e180a451cee778a195f5be4e27e54be6 Mon Sep 17 00:00:00 2001
From: samatstarion <s.gerene@stariongroup.eu>
Date: Sat, 21 Mar 2026 14:45:49 +0100
Subject: [PATCH 7/9] =?UTF-8?q?=20=20#1=20-=20Unsafe=20Parse()=20=E2=86=92?=
 =?UTF-8?q?=20TryParse()=20in=20element=20template=20(core-xmi-reader-part?=
 =?UTF-8?q?ial-for-element-template.hbs)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

  - Replaced bool.Parse(), Enum.Parse(), int.Parse(), double.Parse() with TryParse() patterns
  - Replaced Guid.Parse() for href references with Guid.TryParse()
  - All failures now log warnings with property name, value, and element ID

  #2 - Missing default case in reader switch (core-xmi-reader-template.hbs)
  - Added default: case to both sync and async switch(xmiReader.LocalName) blocks
  - Logs warning with unexpected element name and line/position info
  - Calls xmiReader.Skip() / xmiReader.SkipAsync() to explicitly advance past unrecognized elements

  #3 - Writer instance caching (core-xmi-writer-facade-template.hbs)
  - Writer instances are now created once in the constructor (168 local variables)
  - Captured by lambda closures — no new allocations per element dispatch
  - Removed the loggerFactory field (no longer needed after construction)

  #6 - Silent reference loss logging (core-xmi-reader-partial-for-attribute-template.hbs)
  - Added else branches with logger.LogWarning() for both single and multi-reference Guid.TryParse failures

  #4 - FindNamespaceById optimization (Serializer.cs)
  - Replaced recursive FindNamespaceById() with BuildNamespaceIndex() that builds a Dictionary<Guid, INamespace> once before the loop
  - O(1) lookups instead of O(N) tree walks per source file

  #8 - DI for IXmiDataWriterFacade (Serializer.cs, tests)
  - Serializer constructor now accepts IXmiDataWriterFacade instead of creating XmiDataWriterFacade directly
  - Updated SerializerTestFixture.cs and RoundTripTestFixture.cs to pass facade

  #9 - Mutable elementOriginMap field (DeSerializer.cs)
  - Removed mutable IXmiElementOriginMap elementOriginMap instance field
  - Threaded elementOriginMap as a parameter through the entire method chain: DeSerialize → Read/ReadAsync → ResolveExternalReference/ResolveExternalReferenceAsync
  - DeSerializer instances are now safely reusable across calls with different origin maps
---
 ...-reader-partial-for-attribute-template.hbs |   12 +-
 ...mi-reader-partial-for-element-template.hbs |   94 +-
 .../Uml/core-xmi-reader-template.hbs          |    8 +
 .../Uml/core-xmi-writer-facade-template.hbs   |   15 +-
 .../RoundTripTestFixture.cs                   |    4 +-
 .../SerializerTestFixture.cs                  |    2 +-
 SysML2.NET.Serializer.Xmi/DeSerializer.cs     |   53 +-
 .../AutoGenReaders/AcceptActionUsageReader.cs |  318 ++++-
 .../AutoGenReaders/ActionDefinitionReader.cs  |  156 ++-
 .../AutoGenReaders/ActionUsageReader.cs       |  318 ++++-
 .../AutoGenReaders/ActorMembershipReader.cs   |  176 ++-
 .../AllocationDefinitionReader.cs             |  230 +++-
 .../AutoGenReaders/AllocationUsageReader.cs   |  392 +++++-
 .../AnalysisCaseDefinitionReader.cs           |  156 ++-
 .../AutoGenReaders/AnalysisCaseUsageReader.cs |  318 ++++-
 .../AutoGenReaders/AnnotatingElementReader.cs |   84 +-
 .../AutoGenReaders/AnnotationReader.cs        |  186 ++-
 .../AssertConstraintUsageReader.cs            |  336 ++++-
 .../AssignmentActionUsageReader.cs            |  318 ++++-
 .../AutoGenReaders/AssociationReader.cs       |  194 ++-
 .../AssociationStructureReader.cs             |  194 ++-
 .../AttributeDefinitionReader.cs              |  138 +-
 .../AutoGenReaders/AttributeUsageReader.cs    |  282 +++-
 .../Readers/AutoGenReaders/BehaviorReader.cs  |  120 +-
 .../BindingConnectorAsUsageReader.cs          |  356 ++++-
 .../AutoGenReaders/BindingConnectorReader.cs  |  356 ++++-
 .../AutoGenReaders/BooleanExpressionReader.cs |  282 +++-
 .../CalculationDefinitionReader.cs            |  156 ++-
 .../AutoGenReaders/CalculationUsageReader.cs  |  318 ++++-
 .../AutoGenReaders/CaseDefinitionReader.cs    |  156 ++-
 .../Readers/AutoGenReaders/CaseUsageReader.cs |  318 ++++-
 .../Readers/AutoGenReaders/ClassReader.cs     |  120 +-
 .../AutoGenReaders/ClassifierReader.cs        |  120 +-
 .../AutoGenReaders/CollectExpressionReader.cs |  282 +++-
 .../Readers/AutoGenReaders/CommentReader.cs   |   84 +-
 .../AutoGenReaders/ConcernDefinitionReader.cs |  156 ++-
 .../AutoGenReaders/ConcernUsageReader.cs      |  318 ++++-
 .../ConjugatedPortDefinitionReader.cs         |  156 ++-
 .../ConjugatedPortTypingReader.cs             |  214 ++-
 .../AutoGenReaders/ConjugationReader.cs       |  214 ++-
 .../ConnectionDefinitionReader.cs             |  230 +++-
 .../AutoGenReaders/ConnectionUsageReader.cs   |  392 +++++-
 .../Readers/AutoGenReaders/ConnectorReader.cs |  356 ++++-
 .../ConstraintDefinitionReader.cs             |  156 ++-
 .../AutoGenReaders/ConstraintUsageReader.cs   |  318 ++++-
 .../ConstructorExpressionReader.cs            |  282 +++-
 .../AutoGenReaders/CrossSubsettingReader.cs   |  186 ++-
 .../Readers/AutoGenReaders/DataTypeReader.cs  |  120 +-
 .../AutoGenReaders/DecisionNodeReader.cs      |  318 ++++-
 .../AutoGenReaders/DefinitionReader.cs        |  138 +-
 .../AutoGenReaders/DependencyReader.cs        |  214 ++-
 .../AutoGenReaders/DifferencingReader.cs      |  186 ++-
 .../AutoGenReaders/DisjoiningReader.cs        |  214 ++-
 .../AutoGenReaders/DocumentationReader.cs     |   84 +-
 .../ElementFilterMembershipReader.cs          |  176 ++-
 .../EndFeatureMembershipReader.cs             |  176 ++-
 .../EnumerationDefinitionReader.cs            |  138 +-
 .../AutoGenReaders/EnumerationUsageReader.cs  |  282 +++-
 .../EventOccurrenceUsageReader.cs             |  318 ++++-
 .../AutoGenReaders/ExhibitStateUsageReader.cs |  336 ++++-
 .../AutoGenReaders/ExpressionReader.cs        |  282 +++-
 .../FeatureChainExpressionReader.cs           |  282 +++-
 .../AutoGenReaders/FeatureChainingReader.cs   |  186 ++-
 .../AutoGenReaders/FeatureInvertingReader.cs  |  214 ++-
 .../AutoGenReaders/FeatureMembershipReader.cs |  176 ++-
 .../Readers/AutoGenReaders/FeatureReader.cs   |  282 +++-
 .../FeatureReferenceExpressionReader.cs       |  282 +++-
 .../AutoGenReaders/FeatureTypingReader.cs     |  214 ++-
 .../AutoGenReaders/FeatureValueReader.cs      |  212 ++-
 .../AutoGenReaders/FlowDefinitionReader.cs    |  230 +++-
 .../Readers/AutoGenReaders/FlowEndReader.cs   |  282 +++-
 .../Readers/AutoGenReaders/FlowReader.cs      |  356 ++++-
 .../Readers/AutoGenReaders/FlowUsageReader.cs |  392 +++++-
 .../ForLoopActionUsageReader.cs               |  318 ++++-
 .../Readers/AutoGenReaders/ForkNodeReader.cs  |  318 ++++-
 .../FramedConcernMembershipReader.cs          |  194 ++-
 .../Readers/AutoGenReaders/FunctionReader.cs  |  120 +-
 .../AutoGenReaders/IfActionUsageReader.cs     |  318 ++++-
 .../IncludeUseCaseUsageReader.cs              |  318 ++++-
 .../AutoGenReaders/IndexExpressionReader.cs   |  282 +++-
 .../AutoGenReaders/InteractionReader.cs       |  194 ++-
 .../InterfaceDefinitionReader.cs              |  230 +++-
 .../AutoGenReaders/InterfaceUsageReader.cs    |  392 +++++-
 .../AutoGenReaders/IntersectingReader.cs      |  186 ++-
 .../Readers/AutoGenReaders/InvariantReader.cs |  300 ++++-
 .../InvocationExpressionReader.cs             |  282 +++-
 .../AutoGenReaders/ItemDefinitionReader.cs    |  156 ++-
 .../Readers/AutoGenReaders/ItemUsageReader.cs |  318 ++++-
 .../Readers/AutoGenReaders/JoinNodeReader.cs  |  318 ++++-
 .../AutoGenReaders/LibraryPackageReader.cs    |  102 +-
 .../AutoGenReaders/LiteralBooleanReader.cs    |  300 ++++-
 .../AutoGenReaders/LiteralExpressionReader.cs |  282 +++-
 .../AutoGenReaders/LiteralInfinityReader.cs   |  282 +++-
 .../AutoGenReaders/LiteralIntegerReader.cs    |  300 ++++-
 .../AutoGenReaders/LiteralRationalReader.cs   |  300 ++++-
 .../AutoGenReaders/LiteralStringReader.cs     |  282 +++-
 .../AutoGenReaders/MembershipExposeReader.cs  |  240 +++-
 .../AutoGenReaders/MembershipImportReader.cs  |  240 +++-
 .../AutoGenReaders/MembershipReader.cs        |  204 ++-
 .../Readers/AutoGenReaders/MergeNodeReader.cs |  318 ++++-
 .../Readers/AutoGenReaders/MetaclassReader.cs |  120 +-
 .../MetadataAccessExpressionReader.cs         |  282 +++-
 .../MetadataDefinitionReader.cs               |  156 ++-
 .../AutoGenReaders/MetadataFeatureReader.cs   |  282 +++-
 .../AutoGenReaders/MetadataUsageReader.cs     |  318 ++++-
 .../AutoGenReaders/MultiplicityRangeReader.cs |  282 +++-
 .../AutoGenReaders/MultiplicityReader.cs      |  282 +++-
 .../AutoGenReaders/NamespaceExposeReader.cs   |  240 +++-
 .../AutoGenReaders/NamespaceImportReader.cs   |  240 +++-
 .../Readers/AutoGenReaders/NamespaceReader.cs |   84 +-
 .../AutoGenReaders/NullExpressionReader.cs    |  282 +++-
 .../ObjectiveMembershipReader.cs              |  176 ++-
 .../OccurrenceDefinitionReader.cs             |  156 ++-
 .../AutoGenReaders/OccurrenceUsageReader.cs   |  318 ++++-
 .../OperatorExpressionReader.cs               |  282 +++-
 .../AutoGenReaders/OwningMembershipReader.cs  |  176 ++-
 .../Readers/AutoGenReaders/PackageReader.cs   |   84 +-
 .../ParameterMembershipReader.cs              |  176 ++-
 .../AutoGenReaders/PartDefinitionReader.cs    |  156 ++-
 .../Readers/AutoGenReaders/PartUsageReader.cs |  318 ++++-
 .../AutoGenReaders/PayloadFeatureReader.cs    |  282 +++-
 .../PerformActionUsageReader.cs               |  318 ++++-
 .../AutoGenReaders/PortConjugationReader.cs   |  214 ++-
 .../AutoGenReaders/PortDefinitionReader.cs    |  156 ++-
 .../Readers/AutoGenReaders/PortUsageReader.cs |  318 ++++-
 .../Readers/AutoGenReaders/PredicateReader.cs |  120 +-
 .../AutoGenReaders/RedefinitionReader.cs      |  214 ++-
 .../ReferenceSubsettingReader.cs              |  186 ++-
 .../AutoGenReaders/ReferenceUsageReader.cs    |  282 +++-
 .../RenderingDefinitionReader.cs              |  156 ++-
 .../AutoGenReaders/RenderingUsageReader.cs    |  318 ++++-
 .../RequirementConstraintMembershipReader.cs  |  194 ++-
 .../RequirementDefinitionReader.cs            |  156 ++-
 .../AutoGenReaders/RequirementUsageReader.cs  |  318 ++++-
 ...RequirementVerificationMembershipReader.cs |  194 ++-
 .../ResultExpressionMembershipReader.cs       |  176 ++-
 .../ReturnParameterMembershipReader.cs        |  176 ++-
 .../SatisfyRequirementUsageReader.cs          |  336 ++++-
 .../AutoGenReaders/SelectExpressionReader.cs  |  282 +++-
 .../AutoGenReaders/SendActionUsageReader.cs   |  318 ++++-
 .../AutoGenReaders/SpecializationReader.cs    |  214 ++-
 .../StakeholderMembershipReader.cs            |  176 ++-
 .../AutoGenReaders/StateDefinitionReader.cs   |  174 ++-
 .../StateSubactionMembershipReader.cs         |  194 ++-
 .../AutoGenReaders/StateUsageReader.cs        |  336 ++++-
 .../Readers/AutoGenReaders/StepReader.cs      |  282 +++-
 .../Readers/AutoGenReaders/StructureReader.cs |  120 +-
 .../AutoGenReaders/SubclassificationReader.cs |  214 ++-
 .../AutoGenReaders/SubjectMembershipReader.cs |  176 ++-
 .../AutoGenReaders/SubsettingReader.cs        |  214 ++-
 .../AutoGenReaders/SuccessionAsUsageReader.cs |  356 ++++-
 .../AutoGenReaders/SuccessionFlowReader.cs    |  356 ++++-
 .../SuccessionFlowUsageReader.cs              |  392 +++++-
 .../AutoGenReaders/SuccessionReader.cs        |  356 ++++-
 .../TerminateActionUsageReader.cs             |  318 ++++-
 .../TextualRepresentationReader.cs            |   84 +-
 .../TransitionFeatureMembershipReader.cs      |  194 ++-
 .../AutoGenReaders/TransitionUsageReader.cs   |  318 ++++-
 .../TriggerInvocationExpressionReader.cs      |  300 ++++-
 .../AutoGenReaders/TypeFeaturingReader.cs     |  214 ++-
 .../Readers/AutoGenReaders/TypeReader.cs      |  120 +-
 .../Readers/AutoGenReaders/UnioningReader.cs  |  186 ++-
 .../Readers/AutoGenReaders/UsageReader.cs     |  282 +++-
 .../AutoGenReaders/UseCaseDefinitionReader.cs |  156 ++-
 .../AutoGenReaders/UseCaseUsageReader.cs      |  318 ++++-
 .../AutoGenReaders/VariantMembershipReader.cs |  176 ++-
 .../VerificationCaseDefinitionReader.cs       |  156 ++-
 .../VerificationCaseUsageReader.cs            |  318 ++++-
 .../AutoGenReaders/ViewDefinitionReader.cs    |  156 ++-
 .../ViewRenderingMembershipReader.cs          |  176 ++-
 .../Readers/AutoGenReaders/ViewUsageReader.cs |  318 ++++-
 .../ViewpointDefinitionReader.cs              |  156 ++-
 .../AutoGenReaders/ViewpointUsageReader.cs    |  318 ++++-
 .../WhileLoopActionUsageReader.cs             |  318 ++++-
 SysML2.NET.Serializer.Xmi/Serializer.cs       |   47 +-
 .../AutoGenWriters/XmiDataWriterFacade.cs     | 1175 +++++++----------
 176 files changed, 35855 insertions(+), 5447 deletions(-)

diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-attribute-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-attribute-template.hbs
index adb1294dd..d832881ff 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-attribute-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-attribute-template.hbs
@@ -5,15 +5,19 @@ if(!string.IsNullOrWhiteSpace({{String.LowerCaseFirstLetter property.Name}}XmlAt
 {{#if (Property.QueryIsReferenceProperty property)}}
     {{#if (Property.QueryIsEnumerable property)}}
     var {{String.LowerCaseFirstLetter property.Name}}XmlAttributeReferences = new List<Guid>();
-    
+
     foreach(var {{String.LowerCaseFirstLetter property.Name}}XmlAttributeValue in {{String.LowerCaseFirstLetter property.Name}}XmlAttribute.Split(SplitMultiReference, StringSplitOptions.RemoveEmptyEntries))
     {
         if(Guid.TryParse({{String.LowerCaseFirstLetter property.Name}}XmlAttributeValue, out var {{String.LowerCaseFirstLetter property.Name}}XmlAttributeReference))
         {
             {{String.LowerCaseFirstLetter property.Name}}XmlAttributeReferences.Add({{String.LowerCaseFirstLetter property.Name}}XmlAttributeReference);
         }
+        else
+        {
+            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}XmlAttributeValue, poco.Id);
+        }
     }
-    
+
     if({{String.LowerCaseFirstLetter property.Name}}XmlAttributeReferences.Count != 0)
     {
         this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "{{String.LowerCaseFirstLetter property.Name}}", {{String.LowerCaseFirstLetter property.Name}}XmlAttributeReferences);
@@ -23,6 +27,10 @@ if(!string.IsNullOrWhiteSpace({{String.LowerCaseFirstLetter property.Name}}XmlAt
     {
         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "{{String.LowerCaseFirstLetter property.Name}}", {{String.LowerCaseFirstLetter property.Name}}XmlAttributeReference);
     }
+    else
+    {
+        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}XmlAttribute, poco.Id);
+    }
     {{/if}}
 {{else}}
     {{#if (Property.QueryIsEnumerable property)}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs
index cbdc59d1d..8f86a3cf5 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs
@@ -2,17 +2,23 @@ case"{{String.LowerCaseFirstLetter property.Name}}":
 {
 {{#if (Property.QueryIsReferenceProperty property)}}
     var hrefAttribute = xmiReader.GetAttribute("href");
-    
+
     if(!string.IsNullOrWhiteSpace(hrefAttribute))
     {
         var hrefSplit = hrefAttribute.Split('#');
         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-        var {{String.LowerCaseFirstLetter property.Name}}Id = Guid.Parse(hrefSplit[1]);
-        {{#if (Property.QueryIsEnumerable property)}}
-            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "{{String.LowerCaseFirstLetter property.Name}}", {{String.LowerCaseFirstLetter property.Name}}Id);
-        {{else}}
-            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "{{String.LowerCaseFirstLetter property.Name}}", {{String.LowerCaseFirstLetter property.Name}}Id);
-        {{/if}}
+        if(Guid.TryParse(hrefSplit[1], out var {{String.LowerCaseFirstLetter property.Name}}Id))
+        {
+            {{#if (Property.QueryIsEnumerable property)}}
+                this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "{{String.LowerCaseFirstLetter property.Name}}", {{String.LowerCaseFirstLetter property.Name}}Id);
+            {{else}}
+                this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "{{String.LowerCaseFirstLetter property.Name}}", {{String.LowerCaseFirstLetter property.Name}}Id);
+            {{/if}}
+        }
+        else
+        {
+            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", hrefSplit[1], poco.Id);
+        }
     }
     else
     {
@@ -42,19 +48,47 @@ case"{{String.LowerCaseFirstLetter property.Name}}":
     {{else}}
         var {{String.LowerCaseFirstLetter property.Name}}Value = xmiReader.ReadElementContentAsString();
     {{/if}}
-    
+
     if(!string.IsNullOrWhiteSpace({{String.LowerCaseFirstLetter property.Name}}Value))
     {
     {{#if (Property.QueryIsEnumerable property)}}
         {{#if (Property.QueryIsBool property )}}
-            poco.{{Property.WritePropertyName property}}.Add(bool.Parse({{String.LowerCaseFirstLetter property.Name}}Value));
+            if(bool.TryParse({{String.LowerCaseFirstLetter property.Name}}Value, out var {{String.LowerCaseFirstLetter property.Name}}ValueAsBool))
+            {
+                poco.{{Property.WritePropertyName property}}.Add({{String.LowerCaseFirstLetter property.Name}}ValueAsBool);
+            }
+            else
+            {
+                this.logger.LogWarning("Failed to parse bool value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}Value, poco.Id);
+            }
         {{else if (Property.QueryIsEnum property )}}
-            poco.{{Property.WritePropertyName property}}.Add(({{property.Type.Name}})Enum.Parse(typeof({{property.Type.Name}}), {{String.LowerCaseFirstLetter property.Name}}Value, true));
+            if(Enum.TryParse(typeof({{property.Type.Name}}), {{String.LowerCaseFirstLetter property.Name}}Value, true, out var {{String.LowerCaseFirstLetter property.Name}}ValueAsEnum))
+            {
+                poco.{{Property.WritePropertyName property}}.Add(({{property.Type.Name}}){{String.LowerCaseFirstLetter property.Name}}ValueAsEnum);
+            }
+            else
+            {
+                this.logger.LogWarning("Failed to parse enum value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}Value, poco.Id);
+            }
         {{else if (Property.QueryIsNumeric property )}}
             {{#if (Property.QueryIsInteger property) }}
-                poco.{{Property.WritePropertyName property}}.Add(int.Parse({{String.LowerCaseFirstLetter property.Name}}Value));
+                if(int.TryParse({{String.LowerCaseFirstLetter property.Name}}Value, out var {{String.LowerCaseFirstLetter property.Name}}ValueAsInt))
+                {
+                    poco.{{Property.WritePropertyName property}}.Add({{String.LowerCaseFirstLetter property.Name}}ValueAsInt);
+                }
+                else
+                {
+                    this.logger.LogWarning("Failed to parse int value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}Value, poco.Id);
+                }
             {{else if (Property.QueryIsDouble property) }}
-                poco.{{Property.WritePropertyName property}}.Add(double.Parse({{String.LowerCaseFirstLetter property.Name}}Value));
+                if(double.TryParse({{String.LowerCaseFirstLetter property.Name}}Value, out var {{String.LowerCaseFirstLetter property.Name}}ValueAsDouble))
+                {
+                    poco.{{Property.WritePropertyName property}}.Add({{String.LowerCaseFirstLetter property.Name}}ValueAsDouble);
+                }
+                else
+                {
+                    this.logger.LogWarning("Failed to parse double value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}Value, poco.Id);
+                }
             {{ else }}
                 new NotImplementedException("{{ classContext.Name }}.{{property.Name}} is not yet supported");
             {{/if}}
@@ -63,14 +97,42 @@ case"{{String.LowerCaseFirstLetter property.Name}}":
         {{/if}}
     {{else}}
         {{#if (Property.QueryIsBool property )}}
-            poco.{{Property.WritePropertyName property}} = bool.Parse({{String.LowerCaseFirstLetter property.Name}}Value);
+            if(bool.TryParse({{String.LowerCaseFirstLetter property.Name}}Value, out var {{String.LowerCaseFirstLetter property.Name}}ValueAsBool))
+            {
+                poco.{{Property.WritePropertyName property}} = {{String.LowerCaseFirstLetter property.Name}}ValueAsBool;
+            }
+            else
+            {
+                this.logger.LogWarning("Failed to parse bool value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}Value, poco.Id);
+            }
         {{else if (Property.QueryIsEnum property )}}
-            poco.{{Property.WritePropertyName property}} = ({{property.Type.Name}})Enum.Parse(typeof({{property.Type.Name}}), {{String.LowerCaseFirstLetter property.Name}}Value, true);
+            if(Enum.TryParse(typeof({{property.Type.Name}}), {{String.LowerCaseFirstLetter property.Name}}Value, true, out var {{String.LowerCaseFirstLetter property.Name}}ValueAsEnum))
+            {
+                poco.{{Property.WritePropertyName property}} = ({{property.Type.Name}}){{String.LowerCaseFirstLetter property.Name}}ValueAsEnum;
+            }
+            else
+            {
+                this.logger.LogWarning("Failed to parse enum value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}Value, poco.Id);
+            }
         {{else if (Property.QueryIsNumeric property )}}
             {{#if (Property.QueryIsInteger property) }}
-                poco.{{Property.WritePropertyName property}} = int.Parse({{String.LowerCaseFirstLetter property.Name}}Value);
+                if(int.TryParse({{String.LowerCaseFirstLetter property.Name}}Value, out var {{String.LowerCaseFirstLetter property.Name}}ValueAsInt))
+                {
+                    poco.{{Property.WritePropertyName property}} = {{String.LowerCaseFirstLetter property.Name}}ValueAsInt;
+                }
+                else
+                {
+                    this.logger.LogWarning("Failed to parse int value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}Value, poco.Id);
+                }
             {{else if (Property.QueryIsDouble property) }}
-                poco.{{Property.WritePropertyName property}} = double.Parse({{String.LowerCaseFirstLetter property.Name}}Value);
+                if(double.TryParse({{String.LowerCaseFirstLetter property.Name}}Value, out var {{String.LowerCaseFirstLetter property.Name}}ValueAsDouble))
+                {
+                    poco.{{Property.WritePropertyName property}} = {{String.LowerCaseFirstLetter property.Name}}ValueAsDouble;
+                }
+                else
+                {
+                    this.logger.LogWarning("Failed to parse double value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}Value, poco.Id);
+                }
             {{ else }}
                 new NotImplementedException("{{ classContext.Name }}.{{property.Name}} is not yet supported");
             {{/if}}
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs
index 71dbbd576..55622c7d1 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs
@@ -142,6 +142,10 @@ namespace SysML2.NET.Serializer.Xmi.Readers
                                 {{/unless}}
                             {{/each}}
                             {{/with}}
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading {{this.Name}} at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -225,6 +229,10 @@ namespace SysML2.NET.Serializer.Xmi.Readers
                         {{/unless}}
                     {{/each}}
                     {{/with}}
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading {{this.Name}} at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
index 9a54ee49c..2af934c41 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-writer-facade-template.hbs
@@ -40,11 +40,6 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// </summary>
     public class XmiDataWriterFacade : IXmiDataWriterFacade
     {
-        /// <summary>
-        /// The <see cref="ILoggerFactory"/> used to set up logging for writer instances
-        /// </summary>
-        private readonly ILoggerFactory loggerFactory;
-
         /// <summary>
         /// A dictionary that contains actions that write <see cref="IData"/> based on a key that represents the POCO type name
         /// </summary>
@@ -61,15 +56,16 @@ namespace SysML2.NET.Serializer.Xmi.Writers
         /// <param name="loggerFactory">The <see cref="ILoggerFactory"/> used to set up logging</param>
         public XmiDataWriterFacade(ILoggerFactory loggerFactory)
         {
-            this.loggerFactory = loggerFactory;
+            {{ #each this as | class | }}
+            var {{ String.LowerCaseFirstLetter class.Name }}Writer = new {{ class.Name }}Writer(this, loggerFactory);
+            {{/each}}
 
             this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, XmiWriterOptions, IXmiElementOriginMap, Uri>>
             {
             {{ #each this as | class | }}
                 ["{{ class.Name }}"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new {{ class.Name }}Writer(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, writerOptions, originMap, uri);
+                    {{ String.LowerCaseFirstLetter class.Name }}Writer.Write(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, writerOptions, originMap, uri);
                 },
             {{/each}}
             };
@@ -79,8 +75,7 @@ namespace SysML2.NET.Serializer.Xmi.Writers
             {{ #each this as | class | }}
                 ["{{ class.Name }}"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new {{ class.Name }}Writer(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, writerOptions, originMap, uri);
+                    await {{ String.LowerCaseFirstLetter class.Name }}Writer.WriteAsync(xmlWriter, (Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace class }}.I{{ class.Name }})data, elementName, writerOptions, originMap, uri);
                 },
             {{/each}}
             };
diff --git a/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
index 79af6e56c..a1effe518 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
@@ -103,7 +103,7 @@ public void Verify_that_serialized_output_is_well_formed_xml_with_correct_root()
             Assert.That(originalNamespace, Is.Not.Null);
 
             // Step 2: Serialize to stream
-            var serializer = new Serializer(this.loggerFactory);
+            var serializer = new Serializer(new XmiDataWriterFacade(this.loggerFactory), this.loggerFactory);
             var memoryStream = new MemoryStream();
 
             serializer.Serialize(originalNamespace, this.writerOptions, memoryStream);
@@ -177,7 +177,7 @@ public void VerifySerializedXmlCorrespondToOriginalFile()
 
             var quantityNamespace = deSerializer.DeSerialize(fileUri, originMap);
             
-            var serializer = new Serializer(this.loggerFactory);
+            var serializer = new Serializer(new XmiDataWriterFacade(this.loggerFactory), this.loggerFactory);
             var outputFile = Path.Combine(TestContext.CurrentContext.TestDirectory, "SerializedQuantities.sysmlx");
             
             var fileStream = new FileStream(outputFile, FileMode.Create);
diff --git a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
index 31f81f460..11843b36a 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
@@ -59,7 +59,7 @@ public void Setup()
 
             this.ReadAndAssemblePopulationFromXmiFile();
 
-            this.serializer = new Serializer(serviceProvider.GetRequiredService<ILoggerFactory>());
+            this.serializer = new Serializer(new XmiDataWriterFacade(serviceProvider.GetRequiredService<ILoggerFactory>()), serviceProvider.GetRequiredService<ILoggerFactory>());
         }
 
         [Test]
diff --git a/SysML2.NET.Serializer.Xmi/DeSerializer.cs b/SysML2.NET.Serializer.Xmi/DeSerializer.cs
index 1b6002e0f..14386c640 100644
--- a/SysML2.NET.Serializer.Xmi/DeSerializer.cs
+++ b/SysML2.NET.Serializer.Xmi/DeSerializer.cs
@@ -66,11 +66,6 @@ public class DeSerializer : IDeSerializer
         /// </summary>
         private readonly IXmiDataReaderFacade xmiDataReaderFacade;
 
-        /// <summary>
-        /// The optional <see cref="IXmiElementOriginMap" /> used to track element-to-file associations during deserialization
-        /// </summary>
-        private IXmiElementOriginMap elementOriginMap;
-
         /// <summary>Initializes a new instance of the <see cref="DeSerializer"></see> class.</summary>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService" /> providing external reference file resolve</param>
         /// <param name="xmiDataReaderFacade">
@@ -101,7 +96,7 @@ public DeSerializer(IExternalReferenceService externalReferenceService, IXmiData
         /// </returns>
         public INamespace DeSerialize(Uri fileLocation)
         {
-            return this.DeSerialize(fileLocation, true);
+            return this.DeSerialize(fileLocation, true, null);
         }
 
         /// <summary>
@@ -125,8 +120,7 @@ public INamespace DeSerialize(Uri fileLocation, IXmiElementOriginMap elementOrig
                 throw new ArgumentNullException(nameof(elementOriginMap));
             }
 
-            this.elementOriginMap = elementOriginMap;
-            return this.DeSerialize(fileLocation, true);
+            return this.DeSerialize(fileLocation, true, elementOriginMap);
         }
 
         /// <summary>
@@ -143,7 +137,7 @@ public INamespace DeSerialize(Uri fileLocation, IXmiElementOriginMap elementOrig
         /// </returns>
         public Task<INamespace> DeSerializeAsync(Uri fileLocation, CancellationToken cancellationToken = default)
         {
-            return this.DeSerializeAsync(fileLocation, true, cancellationToken);
+            return this.DeSerializeAsync(fileLocation, true, null, cancellationToken);
         }
 
         /// <summary>
@@ -168,8 +162,7 @@ public Task<INamespace> DeSerializeAsync(Uri fileLocation, IXmiElementOriginMap
                 throw new ArgumentNullException(nameof(elementOriginMap));
             }
 
-            this.elementOriginMap = elementOriginMap;
-            return this.DeSerializeAsync(fileLocation, true, cancellationToken);
+            return this.DeSerializeAsync(fileLocation, true, elementOriginMap, cancellationToken);
         }
 
         /// <summary>
@@ -179,13 +172,14 @@ public Task<INamespace> DeSerializeAsync(Uri fileLocation, IXmiElementOriginMap
         /// the <see cref="Uri" /> that locates the XMI file
         /// </param>
         /// <param name="isRoot">A value indicating whether the reading occurs on the root node</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> to track element-to-file associations</param>
         /// <param name="cancellationToken">An optional <see cref="CancellationToken" /> to cancel the read process</param>
         /// <exception cref="ArgumentNullException">If the <see cref="Uri" /> is null</exception>
         /// <exception cref="FileNotFoundException">If the <see cref="Uri" /> does not locate an existing file</exception>
         /// <returns>
         /// An awaitable <see cref="Task{TResult}" /> with the read <see cref="INamespace" />
         /// </returns>
-        private async Task<INamespace> DeSerializeAsync(Uri fileLocation, bool isRoot, CancellationToken cancellationToken)
+        private async Task<INamespace> DeSerializeAsync(Uri fileLocation, bool isRoot, IXmiElementOriginMap elementOriginMap, CancellationToken cancellationToken)
         {
             AssertValidUri(fileLocation, out var fileInfo);
 
@@ -194,7 +188,7 @@ private async Task<INamespace> DeSerializeAsync(Uri fileLocation, bool isRoot, C
             this.logger.LogInformation("start deserializing from {Path}", fileInfo.Name);
             var stopWatch = Stopwatch.StartNew();
 
-            var result = await this.ReadAsync(fileStream, fileLocation, isRoot, cancellationToken);
+            var result = await this.ReadAsync(fileStream, fileLocation, isRoot, elementOriginMap, cancellationToken);
 
             this.logger.LogInformation("File {Path} deserialized in {ElapsedMilliseconds}[ms]", fileInfo.Name, stopWatch.ElapsedMilliseconds);
 
@@ -209,11 +203,12 @@ private async Task<INamespace> DeSerializeAsync(Uri fileLocation, bool isRoot, C
         /// the <see cref="Uri" /> that locates the XMI file
         /// </param>
         /// <param name="isRoot">A value indicating whether the reading occurs on the root node</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> to track element-to-file associations</param>
         /// <param name="cancellationToken">An optional <see cref="CancellationToken" /> to cancel the read process</param>
         /// <returns>
         /// An awaitable <see cref="Task{TResult}" /> with the read <see cref="INamespace" />
         /// </returns>
-        private async Task<INamespace> ReadAsync(Stream stream, Uri fileLocation, bool isRoot, CancellationToken cancellationToken)
+        private async Task<INamespace> ReadAsync(Stream stream, Uri fileLocation, bool isRoot, IXmiElementOriginMap elementOriginMap, CancellationToken cancellationToken)
         {
             if (cancellationToken.IsCancellationRequested)
             {
@@ -251,14 +246,14 @@ private async Task<INamespace> ReadAsync(Stream stream, Uri fileLocation, bool i
                 return existingNamespace;
             }
 
-            var readNamespace = (INamespace)await this.xmiDataReaderFacade.QueryXmiDataAsync(xmlReader, this.cache, fileLocation, this.externalReferenceService, this.loggerFactory, xmlReader.Name, this.elementOriginMap);
+            var readNamespace = (INamespace)await this.xmiDataReaderFacade.QueryXmiDataAsync(xmlReader, this.cache, fileLocation, this.externalReferenceService, this.loggerFactory, xmlReader.Name, elementOriginMap);
 
-            this.elementOriginMap?.RegisterRootNamespace(fileLocation, readNamespace.Id);
+            elementOriginMap?.RegisterRootNamespace(fileLocation, readNamespace.Id);
 
             stopWatch.Stop();
             this.logger.LogTrace("finished to read xml {DocumentName} in {ElapsedMilliseconds}[ms]", fileInfo.Name, stopWatch.ElapsedMilliseconds);
 
-            await this.ResolveExternalReferenceAsync(cancellationToken);
+            await this.ResolveExternalReferenceAsync(elementOriginMap, cancellationToken);
 
             if (isRoot)
             {
@@ -275,12 +270,13 @@ private async Task<INamespace> ReadAsync(Stream stream, Uri fileLocation, bool i
         /// the <see cref="Uri" /> that locates the XMI file
         /// </param>
         /// <param name="isRoot">A value indicating whether the reading occurs on the root node</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> to track element-to-file associations</param>
         /// <exception cref="ArgumentNullException">If the <see cref="Uri" /> is null</exception>
         /// <exception cref="FileNotFoundException">If the <see cref="Uri" /> does not locate an existing file</exception>
         /// <returns>
         /// The read <see cref="INamespace" />
         /// </returns>
-        private INamespace DeSerialize(Uri fileLocation, bool isRoot)
+        private INamespace DeSerialize(Uri fileLocation, bool isRoot, IXmiElementOriginMap elementOriginMap)
         {
             AssertValidUri(fileLocation, out var fileInfo);
 
@@ -289,7 +285,7 @@ private INamespace DeSerialize(Uri fileLocation, bool isRoot)
             this.logger.LogInformation("start deserializing from {Path}", fileInfo.Name);
             var stopWatch = Stopwatch.StartNew();
 
-            var result = this.Read(fileStream, fileLocation, isRoot);
+            var result = this.Read(fileStream, fileLocation, isRoot, elementOriginMap);
 
             this.logger.LogInformation("File {Path} deserialized in {ElapsedMilliseconds}[ms]", fileInfo.Name, stopWatch.ElapsedMilliseconds);
 
@@ -302,8 +298,9 @@ private INamespace DeSerialize(Uri fileLocation, bool isRoot)
         /// <param name="stream">The content<see cref="Stream" /></param>
         /// <param name="fileLocation">The <see cref="Uri" /> to locate the original <see cref="Stream" /></param>
         /// <param name="isRoot">A value indicating whether the reading occurs on the root node</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> to track element-to-file associations</param>
         /// <returns>The read <see cref="INamespace" /></returns>
-        private INamespace Read(Stream stream, Uri fileLocation, bool isRoot)
+        private INamespace Read(Stream stream, Uri fileLocation, bool isRoot, IXmiElementOriginMap elementOriginMap)
         {
             stream.Seek(0, SeekOrigin.Begin);
             var stopWatch = Stopwatch.StartNew();
@@ -333,14 +330,14 @@ private INamespace Read(Stream stream, Uri fileLocation, bool isRoot)
                 return existingNamespace;
             }
 
-            var readNamespace = (INamespace)this.xmiDataReaderFacade.QueryXmiData(xmlReader, this.cache, fileLocation, this.externalReferenceService, this.loggerFactory, xmlReader.Name, this.elementOriginMap);
+            var readNamespace = (INamespace)this.xmiDataReaderFacade.QueryXmiData(xmlReader, this.cache, fileLocation, this.externalReferenceService, this.loggerFactory, xmlReader.Name, elementOriginMap);
 
-            this.elementOriginMap?.RegisterRootNamespace(fileLocation, readNamespace.Id);
+            elementOriginMap?.RegisterRootNamespace(fileLocation, readNamespace.Id);
 
             stopWatch.Stop();
             this.logger.LogTrace("finished to read xml {DocumentName} in {ElapsedMilliseconds}[ms]", fileInfo.Name, stopWatch.ElapsedMilliseconds);
 
-            this.ResolveExternalReference();
+            this.ResolveExternalReference(elementOriginMap);
 
             if (isRoot)
             {
@@ -353,28 +350,30 @@ private INamespace Read(Stream stream, Uri fileLocation, bool isRoot)
         /// <summary>
         /// Resolve and read all external references
         /// </summary>
-        private void ResolveExternalReference()
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> to track element-to-file associations</param>
+        private void ResolveExternalReference(IXmiElementOriginMap elementOriginMap)
         {
             var references = this.externalReferenceService.GetExternalReferencesToProcess();
 
             foreach (var reference in references)
             {
-                this.DeSerialize(reference, false);
+                this.DeSerialize(reference, false, elementOriginMap);
             }
         }
 
         /// <summary>
         /// Resolve and read all external references asynchronously
         /// </summary>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap" /> to track element-to-file associations</param>
         /// <param name="cancellationToken">The <see cref="CancellationToken" /> to cancel read process</param>
         /// <returns>An awaitable <see cref="Task" /></returns>
-        private async Task ResolveExternalReferenceAsync(CancellationToken cancellationToken)
+        private async Task ResolveExternalReferenceAsync(IXmiElementOriginMap elementOriginMap, CancellationToken cancellationToken)
         {
             var references = this.externalReferenceService.GetExternalReferencesToProcess();
 
             foreach (var reference in references)
             {
-                await this.DeSerializeAsync(reference, false, cancellationToken);
+                await this.DeSerializeAsync(reference, false, elementOriginMap, cancellationToken);
             }
         }
 
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs
index 83f09fbd9..730ab801c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class AcceptActionUsageReader : XmiDataReader<IAcceptActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AcceptActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AcceptActionUsageReader>.Instance : loggerFactory.CreateLogger<AcceptActionUsageReader>();
@@ -311,6 +313,10 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AcceptActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AcceptActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs
index 72d9c0043..f1b68547a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class ActionDefinitionReader : XmiDataReader<IActionDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ActionDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ActionDefinitionReader>.Instance : loggerFactory.CreateLogger<ActionDefinitionReader>();
@@ -227,6 +229,10 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -243,6 +249,10 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -305,7 +315,14 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +334,14 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +353,14 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -341,7 +372,14 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -353,7 +391,14 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,8 +412,14 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -388,8 +439,14 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,6 +458,10 @@ public override IActionDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ActionDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -545,6 +606,10 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -561,6 +626,10 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -623,7 +692,14 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -635,7 +711,14 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -647,7 +730,14 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -659,7 +749,14 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -671,7 +768,14 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,8 +789,14 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -706,8 +816,14 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -719,6 +835,10 @@ public override async Task<IActionDefinition> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ActionDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs
index 9bedda4eb..a4a91e505 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class ActionUsageReader : XmiDataReader<IActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ActionUsageReader>.Instance : loggerFactory.CreateLogger<ActionUsageReader>();
@@ -310,6 +312,10 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -326,6 +332,10 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -386,7 +396,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +427,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +446,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +465,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +484,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +503,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +522,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +541,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +560,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -506,7 +579,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -518,7 +598,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -530,7 +617,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -542,7 +636,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -556,8 +657,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -577,8 +684,14 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,12 +709,23 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -826,6 +950,10 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -842,6 +970,10 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -902,7 +1034,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -926,7 +1065,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -938,7 +1084,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -950,7 +1103,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -962,7 +1122,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -974,7 +1141,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -986,7 +1160,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -998,7 +1179,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1010,7 +1198,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1022,7 +1217,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1034,7 +1236,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1046,7 +1255,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1058,7 +1274,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1072,8 +1295,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1093,8 +1322,14 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1112,12 +1347,23 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs
index 8acdcf921..b26597325 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Parts;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class ActorMembershipReader : XmiDataReader<IActorMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ActorMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ActorMembershipReader>.Instance : loggerFactory.CreateLogger<ActorMembershipReader>();
@@ -177,6 +179,10 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -197,6 +203,10 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -213,6 +223,10 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -223,6 +237,10 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -295,7 +313,14 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -307,7 +332,14 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -321,8 +353,14 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -342,8 +380,14 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -363,8 +407,14 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -384,8 +434,14 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -403,12 +459,23 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ActorMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -523,6 +590,10 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -543,6 +614,10 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -559,6 +634,10 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -569,6 +648,10 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -641,7 +724,14 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -653,7 +743,14 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -667,8 +764,14 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -688,8 +791,14 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -709,8 +818,14 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -730,8 +845,14 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -749,12 +870,23 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ActorMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs
index 7f363dc55..3a8462a61 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class AllocationDefinitionReader : XmiDataReader<IAllocationDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AllocationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AllocationDefinitionReader>.Instance : loggerFactory.CreateLogger<AllocationDefinitionReader>();
@@ -237,6 +239,10 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -257,6 +263,10 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -273,6 +283,10 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -283,6 +297,10 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -345,7 +363,14 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -357,7 +382,14 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -369,7 +401,14 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -381,7 +420,14 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -393,7 +439,14 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -405,7 +458,14 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -419,8 +479,14 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -440,8 +506,14 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -461,8 +533,14 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -482,8 +560,14 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -495,6 +579,10 @@ public override IAllocationDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AllocationDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -649,6 +737,10 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -669,6 +761,10 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -685,6 +781,10 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -695,6 +795,10 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -757,7 +861,14 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -769,7 +880,14 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -781,7 +899,14 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -793,7 +918,14 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -805,7 +937,14 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -817,7 +956,14 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -831,8 +977,14 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -852,8 +1004,14 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -873,8 +1031,14 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -894,8 +1058,14 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -907,6 +1077,10 @@ public override async Task<IAllocationDefinition> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AllocationDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs
index 98d9aa3bb..db73bbe4e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Allocations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -91,6 +92,7 @@ public class AllocationUsageReader : XmiDataReader<IAllocationUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AllocationUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AllocationUsageReader>.Instance : loggerFactory.CreateLogger<AllocationUsageReader>();
@@ -322,6 +324,10 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -342,6 +348,10 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -358,6 +368,10 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -368,6 +382,10 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -428,7 +446,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -452,7 +477,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -464,7 +496,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -476,7 +515,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -488,7 +534,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -500,7 +553,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -512,7 +572,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -524,7 +591,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -536,7 +610,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -548,7 +629,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -560,7 +648,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -572,7 +667,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -584,7 +686,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -596,7 +705,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -610,8 +726,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -631,8 +753,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -652,8 +780,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -673,8 +807,14 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -692,12 +832,23 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AllocationUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -932,6 +1083,10 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -952,6 +1107,10 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -968,6 +1127,10 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -978,6 +1141,10 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -1038,7 +1205,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1062,7 +1236,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1074,7 +1255,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1086,7 +1274,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1098,7 +1293,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1110,7 +1312,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1122,7 +1331,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1134,7 +1350,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1146,7 +1369,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1158,7 +1388,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1170,7 +1407,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1182,7 +1426,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1194,7 +1445,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1206,7 +1464,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1220,8 +1485,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1241,8 +1512,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1262,8 +1539,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1283,8 +1566,14 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1302,12 +1591,23 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AllocationUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs
index cf46ba9f8..241015227 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class AnalysisCaseDefinitionReader : XmiDataReader<IAnalysisCaseDefinitio
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AnalysisCaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AnalysisCaseDefinitionReader>.Instance : loggerFactory.CreateLogger<AnalysisCaseDefinitionReader>();
@@ -228,6 +230,10 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -244,6 +250,10 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -306,7 +316,14 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +335,14 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +354,14 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -342,7 +373,14 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -354,7 +392,14 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -368,8 +413,14 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -389,8 +440,14 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,6 +459,10 @@ public override IAnalysisCaseDefinition Read(XmlReader xmiReader, Uri currentLoc
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AnalysisCaseDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -546,6 +607,10 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -562,6 +627,10 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -624,7 +693,14 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -636,7 +712,14 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -648,7 +731,14 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -660,7 +750,14 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -672,7 +769,14 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -686,8 +790,14 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,8 +817,14 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -720,6 +836,10 @@ public override async Task<IAnalysisCaseDefinition> ReadAsync(XmlReader xmiReade
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AnalysisCaseDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs
index 15486d604..e928c8c05 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class AnalysisCaseUsageReader : XmiDataReader<IAnalysisCaseUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AnalysisCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AnalysisCaseUsageReader>.Instance : loggerFactory.CreateLogger<AnalysisCaseUsageReader>();
@@ -311,6 +313,10 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AnalysisCaseUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AnalysisCaseUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs
index e1c129add..42426a37d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs
@@ -36,6 +36,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -60,6 +61,7 @@ public class AnnotatingElementReader : XmiDataReader<IAnnotatingElement>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AnnotatingElementReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AnnotatingElementReader>.Instance : loggerFactory.CreateLogger<AnnotatingElementReader>();
@@ -161,6 +163,10 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -177,6 +183,10 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -239,7 +249,14 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -253,8 +270,14 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -274,8 +297,14 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -287,6 +316,10 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AnnotatingElement at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -391,6 +424,10 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -407,6 +444,10 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -469,7 +510,14 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,8 +531,14 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -504,8 +558,14 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -517,6 +577,10 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AnnotatingElement at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs
index 625d4294a..93b305aa4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs
@@ -36,6 +36,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -60,6 +61,7 @@ public class AnnotationReader : XmiDataReader<IAnnotation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AnnotationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AnnotationReader>.Instance : loggerFactory.CreateLogger<AnnotationReader>();
@@ -126,6 +128,10 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "annotatedElement", annotatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'annotatedElement' on element {ElementId}", annotatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -181,6 +187,10 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -201,6 +211,10 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -217,6 +231,10 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -227,6 +245,10 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -255,8 +277,14 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var annotatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "annotatedElement", annotatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var annotatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "annotatedElement", annotatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'annotatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -310,7 +338,14 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -322,7 +357,14 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -336,8 +378,14 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -357,8 +405,14 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -378,8 +432,14 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -399,8 +459,14 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -412,6 +478,10 @@ public override IAnnotation Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Annotation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -481,6 +551,10 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "annotatedElement", annotatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'annotatedElement' on element {ElementId}", annotatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -536,6 +610,10 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -556,6 +634,10 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -572,6 +654,10 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -582,6 +668,10 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -610,8 +700,14 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var annotatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "annotatedElement", annotatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var annotatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "annotatedElement", annotatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'annotatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -665,7 +761,14 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -677,7 +780,14 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -691,8 +801,14 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -712,8 +828,14 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -733,8 +855,14 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -754,8 +882,14 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -767,6 +901,10 @@ public override async Task<IAnnotation> ReadAsync(XmlReader xmiReader, Uri curre
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Annotation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs
index ff5bc3a68..68518f70e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class AssertConstraintUsageReader : XmiDataReader<IAssertConstraintUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AssertConstraintUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AssertConstraintUsageReader>.Instance : loggerFactory.CreateLogger<AssertConstraintUsageReader>();
@@ -321,6 +323,10 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -337,6 +343,10 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -397,7 +407,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -421,7 +438,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -433,7 +457,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -445,7 +476,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -457,7 +495,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -469,7 +514,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -481,7 +533,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -493,7 +552,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -505,7 +571,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isNegatedValue))
                                     {
-                                        poco.IsNegated = bool.Parse(isNegatedValue);
+                                        if (bool.TryParse(isNegatedValue, out var isNegatedValueAsBool))
+                                        {
+                                            poco.IsNegated = isNegatedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isNegated' on element {ElementId}", isNegatedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -517,7 +590,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -529,7 +609,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -541,7 +628,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -553,7 +647,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -565,7 +666,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -579,8 +687,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -600,8 +714,14 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -619,12 +739,23 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AssertConstraintUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -859,6 +990,10 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -875,6 +1010,10 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -935,7 +1074,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -959,7 +1105,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -971,7 +1124,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -983,7 +1143,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -995,7 +1162,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1007,7 +1181,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1019,7 +1200,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1031,7 +1219,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1043,7 +1238,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isNegatedValue))
                                     {
-                                        poco.IsNegated = bool.Parse(isNegatedValue);
+                                        if (bool.TryParse(isNegatedValue, out var isNegatedValueAsBool))
+                                        {
+                                            poco.IsNegated = isNegatedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isNegated' on element {ElementId}", isNegatedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1055,7 +1257,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1067,7 +1276,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1079,7 +1295,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1091,7 +1314,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1103,7 +1333,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1117,8 +1354,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1138,8 +1381,14 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1157,12 +1406,23 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AssertConstraintUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs
index 3cc588da3..631bebe42 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class AssignmentActionUsageReader : XmiDataReader<IAssignmentActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AssignmentActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AssignmentActionUsageReader>.Instance : loggerFactory.CreateLogger<AssignmentActionUsageReader>();
@@ -311,6 +313,10 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AssignmentActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AssignmentActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs
index 7357a957f..66ca8d6a6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class AssociationReader : XmiDataReader<IAssociation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AssociationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AssociationReader>.Instance : loggerFactory.CreateLogger<AssociationReader>();
@@ -195,6 +197,10 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -215,6 +221,10 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -231,6 +241,10 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -241,6 +255,10 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -303,7 +321,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -315,7 +340,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -327,7 +359,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -339,7 +378,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -353,8 +399,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -374,8 +426,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -395,8 +453,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -416,8 +480,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -429,6 +499,10 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Association at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -563,6 +637,10 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -583,6 +661,10 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -599,6 +681,10 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -609,6 +695,10 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -671,7 +761,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -683,7 +780,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -695,7 +799,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -707,7 +818,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -721,8 +839,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -742,8 +866,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -763,8 +893,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -784,8 +920,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -797,6 +939,10 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Association at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs
index 16dab3e14..9e6ebc3a6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Associations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class AssociationStructureReader : XmiDataReader<IAssociationStructure>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AssociationStructureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AssociationStructureReader>.Instance : loggerFactory.CreateLogger<AssociationStructureReader>();
@@ -196,6 +198,10 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -216,6 +222,10 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -232,6 +242,10 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -242,6 +256,10 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -304,7 +322,14 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -316,7 +341,14 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -328,7 +360,14 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -340,7 +379,14 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -354,8 +400,14 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -375,8 +427,14 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -396,8 +454,14 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -417,8 +481,14 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -430,6 +500,10 @@ public override IAssociationStructure Read(XmlReader xmiReader, Uri currentLocat
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AssociationStructure at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -564,6 +638,10 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -584,6 +662,10 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -600,6 +682,10 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -610,6 +696,10 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -672,7 +762,14 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -684,7 +781,14 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -696,7 +800,14 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -708,7 +819,14 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -722,8 +840,14 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -743,8 +867,14 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -764,8 +894,14 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -785,8 +921,14 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -798,6 +940,10 @@ public override async Task<IAssociationStructure> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AssociationStructure at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs
index 8849373f9..4e558dd47 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class AttributeDefinitionReader : XmiDataReader<IAttributeDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AttributeDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AttributeDefinitionReader>.Instance : loggerFactory.CreateLogger<AttributeDefinitionReader>();
@@ -217,6 +219,10 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -233,6 +239,10 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -295,7 +305,14 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -307,7 +324,14 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -319,7 +343,14 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -331,7 +362,14 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -345,8 +383,14 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -366,8 +410,14 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -379,6 +429,10 @@ public override IAttributeDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AttributeDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -513,6 +567,10 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -529,6 +587,10 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -591,7 +653,14 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -603,7 +672,14 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -615,7 +691,14 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -627,7 +710,14 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -641,8 +731,14 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -662,8 +758,14 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -675,6 +777,10 @@ public override async Task<IAttributeDefinition> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AttributeDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs
index c8ac97548..0bd97f3bc 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Attributes;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class AttributeUsageReader : XmiDataReader<IAttributeUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public AttributeUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<AttributeUsageReader>.Instance : loggerFactory.CreateLogger<AttributeUsageReader>();
@@ -298,6 +300,10 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -314,6 +320,10 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -364,7 +374,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -388,7 +405,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -400,7 +424,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -412,7 +443,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -424,7 +462,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -436,7 +481,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -448,7 +500,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -460,7 +519,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -472,7 +538,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -484,7 +557,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -496,7 +576,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -508,7 +595,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -522,8 +616,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -543,8 +643,14 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -556,6 +662,10 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AttributeUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -770,6 +880,10 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -786,6 +900,10 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -836,7 +954,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -860,7 +985,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -872,7 +1004,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -884,7 +1023,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -896,7 +1042,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -908,7 +1061,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -920,7 +1080,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -932,7 +1099,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -944,7 +1118,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -956,7 +1137,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -968,7 +1156,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -980,7 +1175,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -994,8 +1196,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1015,8 +1223,14 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1028,6 +1242,10 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AttributeUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs
index f4b03f555..c87cd2012 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class BehaviorReader : XmiDataReader<IBehavior>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public BehaviorReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<BehaviorReader>.Instance : loggerFactory.CreateLogger<BehaviorReader>();
@@ -186,6 +188,10 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -202,6 +208,10 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -264,7 +274,14 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -276,7 +293,14 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -288,7 +312,14 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -302,8 +333,14 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -323,8 +360,14 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -336,6 +379,10 @@ public override IBehavior Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Behavior at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -460,6 +507,10 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -476,6 +527,10 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -538,7 +593,14 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -550,7 +612,14 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -562,7 +631,14 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -576,8 +652,14 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,8 +679,14 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -610,6 +698,10 @@ public override async Task<IBehavior> ReadAsync(XmlReader xmiReader, Uri current
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Behavior at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs
index b564d34ba..60412af40 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -88,6 +89,7 @@ public class BindingConnectorAsUsageReader : XmiDataReader<IBindingConnectorAsUs
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public BindingConnectorAsUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<BindingConnectorAsUsageReader>.Instance : loggerFactory.CreateLogger<BindingConnectorAsUsageReader>();
@@ -309,6 +311,10 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -329,6 +335,10 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -345,6 +355,10 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -355,6 +369,10 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -405,7 +423,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -429,7 +454,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -441,7 +473,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -453,7 +492,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -465,7 +511,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -477,7 +530,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -489,7 +549,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,7 +568,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -513,7 +587,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -525,7 +606,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -537,7 +625,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -549,7 +644,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -561,7 +663,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -575,8 +684,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,8 +711,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -617,8 +738,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -638,8 +765,14 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -651,6 +784,10 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading BindingConnectorAsUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -875,6 +1012,10 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -895,6 +1036,10 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -911,6 +1056,10 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -921,6 +1070,10 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -971,7 +1124,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -995,7 +1155,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1007,7 +1174,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1019,7 +1193,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1031,7 +1212,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1043,7 +1231,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1055,7 +1250,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1067,7 +1269,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1079,7 +1288,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1091,7 +1307,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1103,7 +1326,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1115,7 +1345,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1127,7 +1364,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1141,8 +1385,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1162,8 +1412,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1183,8 +1439,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1204,8 +1466,14 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1217,6 +1485,10 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading BindingConnectorAsUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs
index db51ccd68..a76af3a7b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class BindingConnectorReader : XmiDataReader<IBindingConnector>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public BindingConnectorReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<BindingConnectorReader>.Instance : loggerFactory.CreateLogger<BindingConnectorReader>();
@@ -286,6 +288,10 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -306,6 +312,10 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -322,6 +332,10 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -332,6 +346,10 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -382,7 +400,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -406,7 +431,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -418,7 +450,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -430,7 +469,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -442,7 +488,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -454,7 +507,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -466,7 +526,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -478,7 +545,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -490,7 +564,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -502,7 +583,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -514,7 +602,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -526,7 +621,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -538,7 +640,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -552,8 +661,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -573,8 +688,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -594,8 +715,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -615,8 +742,14 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -628,6 +761,10 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading BindingConnector at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -852,6 +989,10 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -872,6 +1013,10 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -888,6 +1033,10 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -898,6 +1047,10 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -948,7 +1101,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -972,7 +1132,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -984,7 +1151,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -996,7 +1170,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1008,7 +1189,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1020,7 +1208,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1032,7 +1227,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1044,7 +1246,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1056,7 +1265,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1068,7 +1284,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1080,7 +1303,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1092,7 +1322,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1104,7 +1341,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1118,8 +1362,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1139,8 +1389,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1160,8 +1416,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1181,8 +1443,14 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1194,6 +1462,10 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading BindingConnector at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs
index 8ee41bac1..454f8320c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class BooleanExpressionReader : XmiDataReader<IBooleanExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public BooleanExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<BooleanExpressionReader>.Instance : loggerFactory.CreateLogger<BooleanExpressionReader>();
@@ -276,6 +278,10 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -292,6 +298,10 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -342,7 +352,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -366,7 +383,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -378,7 +402,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -390,7 +421,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -402,7 +440,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -414,7 +459,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -426,7 +478,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -438,7 +497,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -450,7 +516,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -462,7 +535,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -474,7 +554,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -486,7 +573,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -500,8 +594,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -521,8 +621,14 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -534,6 +640,10 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading BooleanExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -748,6 +858,10 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -764,6 +878,10 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -814,7 +932,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -838,7 +963,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -850,7 +982,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -862,7 +1001,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -874,7 +1020,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -886,7 +1039,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -898,7 +1058,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -910,7 +1077,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -922,7 +1096,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -934,7 +1115,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -946,7 +1134,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -958,7 +1153,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -972,8 +1174,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -993,8 +1201,14 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1006,6 +1220,10 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading BooleanExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs
index fa19345e4..8485283f9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class CalculationDefinitionReader : XmiDataReader<ICalculationDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public CalculationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CalculationDefinitionReader>.Instance : loggerFactory.CreateLogger<CalculationDefinitionReader>();
@@ -228,6 +230,10 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -244,6 +250,10 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -306,7 +316,14 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +335,14 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +354,14 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -342,7 +373,14 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -354,7 +392,14 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -368,8 +413,14 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -389,8 +440,14 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,6 +459,10 @@ public override ICalculationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CalculationDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -546,6 +607,10 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -562,6 +627,10 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -624,7 +693,14 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -636,7 +712,14 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -648,7 +731,14 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -660,7 +750,14 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -672,7 +769,14 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -686,8 +790,14 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,8 +817,14 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -720,6 +836,10 @@ public override async Task<ICalculationDefinition> ReadAsync(XmlReader xmiReader
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CalculationDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs
index 9e9749d6f..e589bd96a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Calculations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class CalculationUsageReader : XmiDataReader<ICalculationUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public CalculationUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CalculationUsageReader>.Instance : loggerFactory.CreateLogger<CalculationUsageReader>();
@@ -311,6 +313,10 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CalculationUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CalculationUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs
index a6dc48ce7..fdb90d4cd 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class CaseDefinitionReader : XmiDataReader<ICaseDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public CaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CaseDefinitionReader>.Instance : loggerFactory.CreateLogger<CaseDefinitionReader>();
@@ -228,6 +230,10 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -244,6 +250,10 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -306,7 +316,14 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +335,14 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +354,14 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -342,7 +373,14 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -354,7 +392,14 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -368,8 +413,14 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -389,8 +440,14 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,6 +459,10 @@ public override ICaseDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CaseDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -546,6 +607,10 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -562,6 +627,10 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -624,7 +693,14 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -636,7 +712,14 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -648,7 +731,14 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -660,7 +750,14 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -672,7 +769,14 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -686,8 +790,14 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,8 +817,14 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -720,6 +836,10 @@ public override async Task<ICaseDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CaseDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs
index 857ee1a3f..785484ffd 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class CaseUsageReader : XmiDataReader<ICaseUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public CaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CaseUsageReader>.Instance : loggerFactory.CreateLogger<CaseUsageReader>();
@@ -311,6 +313,10 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CaseUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CaseUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs
index 5cfabf509..0e2cecede 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Classes;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class ClassReader : XmiDataReader<IClass>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ClassReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ClassReader>.Instance : loggerFactory.CreateLogger<ClassReader>();
@@ -185,6 +187,10 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -201,6 +207,10 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -263,7 +273,14 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -275,7 +292,14 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -287,7 +311,14 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -301,8 +332,14 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -322,8 +359,14 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -335,6 +378,10 @@ public override IClass Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Class at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -459,6 +506,10 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -475,6 +526,10 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -537,7 +592,14 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -549,7 +611,14 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -561,7 +630,14 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -575,8 +651,14 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,8 +678,14 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -609,6 +697,10 @@ public override async Task<IClass> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Class at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs
index 2219db3e7..db8686182 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -63,6 +64,7 @@ public class ClassifierReader : XmiDataReader<IClassifier>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ClassifierReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ClassifierReader>.Instance : loggerFactory.CreateLogger<ClassifierReader>();
@@ -184,6 +186,10 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -200,6 +206,10 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -262,7 +272,14 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -274,7 +291,14 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -286,7 +310,14 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -300,8 +331,14 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -321,8 +358,14 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -334,6 +377,10 @@ public override IClassifier Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Classifier at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -458,6 +505,10 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -474,6 +525,10 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -536,7 +591,14 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -548,7 +610,14 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -560,7 +629,14 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -574,8 +650,14 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -595,8 +677,14 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -608,6 +696,10 @@ public override async Task<IClassifier> ReadAsync(XmlReader xmiReader, Uri curre
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Classifier at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs
index eac3938d2..4c6e892a7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class CollectExpressionReader : XmiDataReader<ICollectExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public CollectExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CollectExpressionReader>.Instance : loggerFactory.CreateLogger<CollectExpressionReader>();
@@ -284,6 +286,10 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -300,6 +306,10 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -350,7 +360,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -374,7 +391,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -386,7 +410,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -398,7 +429,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +448,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +467,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +486,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +505,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +524,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +543,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +562,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +581,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -520,8 +614,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -541,8 +641,14 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -554,6 +660,10 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CollectExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -775,6 +885,10 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -791,6 +905,10 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -841,7 +959,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -865,7 +990,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -877,7 +1009,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -889,7 +1028,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -901,7 +1047,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -913,7 +1066,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -925,7 +1085,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -937,7 +1104,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -949,7 +1123,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -961,7 +1142,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,7 +1161,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -985,7 +1180,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,8 +1213,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1032,8 +1240,14 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1045,6 +1259,10 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CollectExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs
index 50e095542..ad0d45e9d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs
@@ -36,6 +36,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -60,6 +61,7 @@ public class CommentReader : XmiDataReader<IComment>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public CommentReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CommentReader>.Instance : loggerFactory.CreateLogger<CommentReader>();
@@ -175,6 +177,10 @@ public override IComment Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -191,6 +197,10 @@ public override IComment Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -265,7 +275,14 @@ public override IComment Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -291,8 +308,14 @@ public override IComment Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -312,8 +335,14 @@ public override IComment Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -325,6 +354,10 @@ public override IComment Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Comment at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -443,6 +476,10 @@ public override async Task<IComment> ReadAsync(XmlReader xmiReader, Uri currentL
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -459,6 +496,10 @@ public override async Task<IComment> ReadAsync(XmlReader xmiReader, Uri currentL
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -533,7 +574,14 @@ public override async Task<IComment> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -559,8 +607,14 @@ public override async Task<IComment> ReadAsync(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -580,8 +634,14 @@ public override async Task<IComment> ReadAsync(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -593,6 +653,10 @@ public override async Task<IComment> ReadAsync(XmlReader xmiReader, Uri currentL
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Comment at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs
index cbfec0828..3b248a833 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class ConcernDefinitionReader : XmiDataReader<IConcernDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConcernDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConcernDefinitionReader>.Instance : loggerFactory.CreateLogger<ConcernDefinitionReader>();
@@ -221,6 +223,10 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -237,6 +243,10 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var reqIdXmlAttribute = xmiReader.GetAttribute("reqId");
@@ -294,7 +304,14 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -306,7 +323,14 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +342,14 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +361,14 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -342,7 +380,14 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -356,8 +401,14 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -377,8 +428,14 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,6 +459,10 @@ public override IConcernDefinition Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConcernDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -539,6 +600,10 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -555,6 +620,10 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var reqIdXmlAttribute = xmiReader.GetAttribute("reqId");
@@ -612,7 +681,14 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -624,7 +700,14 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -636,7 +719,14 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -648,7 +738,14 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -660,7 +757,14 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -674,8 +778,14 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -695,8 +805,14 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -720,6 +836,10 @@ public override async Task<IConcernDefinition> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConcernDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs
index a11d7792f..b77251a0c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class ConcernUsageReader : XmiDataReader<IConcernUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConcernUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConcernUsageReader>.Instance : loggerFactory.CreateLogger<ConcernUsageReader>();
@@ -304,6 +306,10 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -320,6 +326,10 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -375,7 +385,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -399,7 +416,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +435,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +454,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +473,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +492,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +511,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +530,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +549,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +568,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +587,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +606,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +625,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -545,8 +646,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -566,8 +673,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -585,7 +698,14 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -603,6 +723,10 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConcernUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -820,6 +944,10 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -836,6 +964,10 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -891,7 +1023,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -915,7 +1054,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1073,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1092,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1111,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1130,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1149,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1168,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1187,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1206,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1225,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1244,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1263,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1061,8 +1284,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1082,8 +1311,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1101,7 +1336,14 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1119,6 +1361,10 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConcernUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs
index b74c75e32..3e0458326 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs
@@ -61,6 +61,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -85,6 +86,7 @@ public class ConjugatedPortDefinitionReader : XmiDataReader<IConjugatedPortDefin
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConjugatedPortDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConjugatedPortDefinitionReader>.Instance : loggerFactory.CreateLogger<ConjugatedPortDefinitionReader>();
@@ -226,6 +228,10 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -242,6 +248,10 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -304,7 +314,14 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -316,7 +333,14 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -328,7 +352,14 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -340,7 +371,14 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -352,7 +390,14 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -366,8 +411,14 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -387,8 +438,14 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,6 +457,10 @@ public override IConjugatedPortDefinition Read(XmlReader xmiReader, Uri currentL
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConjugatedPortDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -544,6 +605,10 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -560,6 +625,10 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -622,7 +691,14 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -634,7 +710,14 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -646,7 +729,14 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -658,7 +748,14 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -670,7 +767,14 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -684,8 +788,14 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -705,8 +815,14 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -718,6 +834,10 @@ public override async Task<IConjugatedPortDefinition> ReadAsync(XmlReader xmiRea
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConjugatedPortDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs
index 4b40a7a32..f3629e05c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -63,6 +64,7 @@ public class ConjugatedPortTypingReader : XmiDataReader<IConjugatedPortTyping>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConjugatedPortTypingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConjugatedPortTypingReader>.Instance : loggerFactory.CreateLogger<ConjugatedPortTypingReader>();
@@ -129,6 +131,10 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedPortDefinition", conjugatedPortDefinitionXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'conjugatedPortDefinition' on element {ElementId}", conjugatedPortDefinitionXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -184,6 +190,10 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -204,6 +214,10 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -220,6 +234,10 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -230,6 +248,10 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typedFeatureXmlAttribute = xmiReader.GetAttribute("typedFeature");
@@ -240,6 +262,10 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'typedFeature' on element {ElementId}", typedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -268,8 +294,14 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var conjugatedPortDefinitionId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedPortDefinition", conjugatedPortDefinitionId);
+                                        if (Guid.TryParse(hrefSplit[1], out var conjugatedPortDefinitionId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedPortDefinition", conjugatedPortDefinitionId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'conjugatedPortDefinition' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -323,7 +355,14 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -335,7 +374,14 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -349,8 +395,14 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -370,8 +422,14 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -391,8 +449,14 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -412,8 +476,14 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -433,8 +503,14 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'typedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -446,6 +522,10 @@ public override IConjugatedPortTyping Read(XmlReader xmiReader, Uri currentLocat
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConjugatedPortTyping at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -515,6 +595,10 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedPortDefinition", conjugatedPortDefinitionXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'conjugatedPortDefinition' on element {ElementId}", conjugatedPortDefinitionXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -570,6 +654,10 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -590,6 +678,10 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -606,6 +698,10 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -616,6 +712,10 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typedFeatureXmlAttribute = xmiReader.GetAttribute("typedFeature");
@@ -626,6 +726,10 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'typedFeature' on element {ElementId}", typedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -654,8 +758,14 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var conjugatedPortDefinitionId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedPortDefinition", conjugatedPortDefinitionId);
+                                        if (Guid.TryParse(hrefSplit[1], out var conjugatedPortDefinitionId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedPortDefinition", conjugatedPortDefinitionId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'conjugatedPortDefinition' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -709,7 +819,14 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -721,7 +838,14 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -735,8 +859,14 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -756,8 +886,14 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -777,8 +913,14 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -798,8 +940,14 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -819,8 +967,14 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'typedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -832,6 +986,10 @@ public override async Task<IConjugatedPortTyping> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConjugatedPortTyping at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs
index 54f56de55..d427ec163 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class ConjugationReader : XmiDataReader<IConjugation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConjugationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConjugationReader>.Instance : loggerFactory.CreateLogger<ConjugationReader>();
@@ -127,6 +129,10 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'conjugatedType' on element {ElementId}", conjugatedTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -178,6 +184,10 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalType", originalTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'originalType' on element {ElementId}", originalTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var ownedRelatedElementXmlAttribute = xmiReader.GetAttribute("ownedRelatedElement");
@@ -192,6 +202,10 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -212,6 +226,10 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -228,6 +246,10 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -238,6 +260,10 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -266,8 +292,14 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var conjugatedTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var conjugatedTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'conjugatedType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -321,7 +353,14 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -333,7 +372,14 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -347,8 +393,14 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var originalTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalType", originalTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var originalTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalType", originalTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'originalType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -368,8 +420,14 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -389,8 +447,14 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -410,8 +474,14 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -431,8 +501,14 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -444,6 +520,10 @@ public override IConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Conjugation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -513,6 +593,10 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'conjugatedType' on element {ElementId}", conjugatedTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -564,6 +648,10 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalType", originalTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'originalType' on element {ElementId}", originalTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var ownedRelatedElementXmlAttribute = xmiReader.GetAttribute("ownedRelatedElement");
@@ -578,6 +666,10 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -598,6 +690,10 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -614,6 +710,10 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -624,6 +724,10 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -652,8 +756,14 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var conjugatedTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var conjugatedTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'conjugatedType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,7 +817,14 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -719,7 +836,14 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -733,8 +857,14 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var originalTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalType", originalTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var originalTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalType", originalTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'originalType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -754,8 +884,14 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -775,8 +911,14 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -796,8 +938,14 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -817,8 +965,14 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -830,6 +984,10 @@ public override async Task<IConjugation> ReadAsync(XmlReader xmiReader, Uri curr
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Conjugation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs
index c89a97ae8..4f1f3d7ce 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class ConnectionDefinitionReader : XmiDataReader<IConnectionDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConnectionDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConnectionDefinitionReader>.Instance : loggerFactory.CreateLogger<ConnectionDefinitionReader>();
@@ -237,6 +239,10 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -257,6 +263,10 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -273,6 +283,10 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -283,6 +297,10 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -345,7 +363,14 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -357,7 +382,14 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -369,7 +401,14 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -381,7 +420,14 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -393,7 +439,14 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -405,7 +458,14 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -419,8 +479,14 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -440,8 +506,14 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -461,8 +533,14 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -482,8 +560,14 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -495,6 +579,10 @@ public override IConnectionDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConnectionDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -649,6 +737,10 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -669,6 +761,10 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -685,6 +781,10 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -695,6 +795,10 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -757,7 +861,14 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -769,7 +880,14 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -781,7 +899,14 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -793,7 +918,14 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -805,7 +937,14 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -817,7 +956,14 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -831,8 +977,14 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -852,8 +1004,14 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -873,8 +1031,14 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -894,8 +1058,14 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -907,6 +1077,10 @@ public override async Task<IConnectionDefinition> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConnectionDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs
index c8596b18b..56180ac7c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -91,6 +92,7 @@ public class ConnectionUsageReader : XmiDataReader<IConnectionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConnectionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConnectionUsageReader>.Instance : loggerFactory.CreateLogger<ConnectionUsageReader>();
@@ -322,6 +324,10 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -342,6 +348,10 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -358,6 +368,10 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -368,6 +382,10 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -428,7 +446,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -452,7 +477,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -464,7 +496,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -476,7 +515,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -488,7 +534,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -500,7 +553,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -512,7 +572,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -524,7 +591,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -536,7 +610,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -548,7 +629,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -560,7 +648,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -572,7 +667,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -584,7 +686,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -596,7 +705,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -610,8 +726,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -631,8 +753,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -652,8 +780,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -673,8 +807,14 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -692,12 +832,23 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConnectionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -932,6 +1083,10 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -952,6 +1107,10 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -968,6 +1127,10 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -978,6 +1141,10 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -1038,7 +1205,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1062,7 +1236,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1074,7 +1255,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1086,7 +1274,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1098,7 +1293,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1110,7 +1312,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1122,7 +1331,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1134,7 +1350,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1146,7 +1369,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1158,7 +1388,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1170,7 +1407,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1182,7 +1426,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1194,7 +1445,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1206,7 +1464,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1220,8 +1485,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1241,8 +1512,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1262,8 +1539,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1283,8 +1566,14 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1302,12 +1591,23 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConnectionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs
index c90ff0f25..7d0e03566 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class ConnectorReader : XmiDataReader<IConnector>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConnectorReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConnectorReader>.Instance : loggerFactory.CreateLogger<ConnectorReader>();
@@ -286,6 +288,10 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -306,6 +312,10 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -322,6 +332,10 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -332,6 +346,10 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -382,7 +400,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -406,7 +431,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -418,7 +450,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -430,7 +469,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -442,7 +488,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -454,7 +507,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -466,7 +526,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -478,7 +545,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -490,7 +564,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -502,7 +583,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -514,7 +602,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -526,7 +621,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -538,7 +640,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -552,8 +661,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -573,8 +688,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -594,8 +715,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -615,8 +742,14 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -628,6 +761,10 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Connector at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -852,6 +989,10 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -872,6 +1013,10 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -888,6 +1033,10 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -898,6 +1047,10 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -948,7 +1101,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -972,7 +1132,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -984,7 +1151,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -996,7 +1170,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1008,7 +1189,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1020,7 +1208,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1032,7 +1227,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1044,7 +1246,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1056,7 +1265,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1068,7 +1284,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1080,7 +1303,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1092,7 +1322,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1104,7 +1341,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1118,8 +1362,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1139,8 +1389,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1160,8 +1416,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1181,8 +1443,14 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1194,6 +1462,10 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Connector at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs
index 780c35829..cac4a6be8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class ConstraintDefinitionReader : XmiDataReader<IConstraintDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConstraintDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConstraintDefinitionReader>.Instance : loggerFactory.CreateLogger<ConstraintDefinitionReader>();
@@ -228,6 +230,10 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -244,6 +250,10 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -306,7 +316,14 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +335,14 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +354,14 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -342,7 +373,14 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -354,7 +392,14 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -368,8 +413,14 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -389,8 +440,14 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,6 +459,10 @@ public override IConstraintDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConstraintDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -546,6 +607,10 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -562,6 +627,10 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -624,7 +693,14 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -636,7 +712,14 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -648,7 +731,14 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -660,7 +750,14 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -672,7 +769,14 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -686,8 +790,14 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,8 +817,14 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -720,6 +836,10 @@ public override async Task<IConstraintDefinition> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConstraintDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs
index 0f2f25753..2bb033fd5 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Constraints;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class ConstraintUsageReader : XmiDataReader<IConstraintUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConstraintUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConstraintUsageReader>.Instance : loggerFactory.CreateLogger<ConstraintUsageReader>();
@@ -311,6 +313,10 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConstraintUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConstraintUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs
index b7f3c0d1c..e663b24f9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class ConstructorExpressionReader : XmiDataReader<IConstructorExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ConstructorExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ConstructorExpressionReader>.Instance : loggerFactory.CreateLogger<ConstructorExpressionReader>();
@@ -277,6 +279,10 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -343,7 +353,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,7 +384,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -379,7 +403,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,7 +422,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -403,7 +441,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -415,7 +460,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -427,7 +479,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -439,7 +498,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -451,7 +517,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -463,7 +536,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -475,7 +555,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -487,7 +574,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,8 +595,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -522,8 +622,14 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -535,6 +641,10 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConstructorExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -749,6 +859,10 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -765,6 +879,10 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -815,7 +933,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -839,7 +964,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -851,7 +983,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -863,7 +1002,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -875,7 +1021,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -887,7 +1040,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -899,7 +1059,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -911,7 +1078,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -923,7 +1097,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -935,7 +1116,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -947,7 +1135,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -959,7 +1154,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,8 +1175,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -994,8 +1202,14 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1007,6 +1221,10 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ConstructorExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs
index 178470ac4..5fab7ed2a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class CrossSubsettingReader : XmiDataReader<ICrossSubsetting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public CrossSubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<CrossSubsettingReader>.Instance : loggerFactory.CreateLogger<CrossSubsettingReader>();
@@ -128,6 +130,10 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "crossedFeature", crossedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'crossedFeature' on element {ElementId}", crossedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -183,6 +189,10 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -203,6 +213,10 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -219,6 +233,10 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -229,6 +247,10 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -257,8 +279,14 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var crossedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "crossedFeature", crossedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var crossedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "crossedFeature", crossedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'crossedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -312,7 +340,14 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -324,7 +359,14 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -338,8 +380,14 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -359,8 +407,14 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -380,8 +434,14 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,8 +461,14 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -414,6 +480,10 @@ public override ICrossSubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CrossSubsetting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -483,6 +553,10 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "crossedFeature", crossedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'crossedFeature' on element {ElementId}", crossedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -538,6 +612,10 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -558,6 +636,10 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -574,6 +656,10 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -584,6 +670,10 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -612,8 +702,14 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var crossedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "crossedFeature", crossedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var crossedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "crossedFeature", crossedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'crossedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -667,7 +763,14 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -679,7 +782,14 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -693,8 +803,14 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -714,8 +830,14 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -735,8 +857,14 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -756,8 +884,14 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -769,6 +903,10 @@ public override async Task<ICrossSubsetting> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading CrossSubsetting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs
index 7911b81a8..b66f57b36 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.DataTypes;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class DataTypeReader : XmiDataReader<IDataType>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public DataTypeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DataTypeReader>.Instance : loggerFactory.CreateLogger<DataTypeReader>();
@@ -185,6 +187,10 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -201,6 +207,10 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -263,7 +273,14 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -275,7 +292,14 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -287,7 +311,14 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -301,8 +332,14 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -322,8 +359,14 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -335,6 +378,10 @@ public override IDataType Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading DataType at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -459,6 +506,10 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -475,6 +526,10 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -537,7 +592,14 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -549,7 +611,14 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -561,7 +630,14 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -575,8 +651,14 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,8 +678,14 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -609,6 +697,10 @@ public override async Task<IDataType> ReadAsync(XmlReader xmiReader, Uri current
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading DataType at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs
index 7a38e20d1..d910eaf7c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class DecisionNodeReader : XmiDataReader<IDecisionNode>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public DecisionNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DecisionNodeReader>.Instance : loggerFactory.CreateLogger<DecisionNodeReader>();
@@ -310,6 +312,10 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -326,6 +332,10 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -386,7 +396,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +427,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +446,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +465,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +484,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +503,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +522,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +541,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +560,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -506,7 +579,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -518,7 +598,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -530,7 +617,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -542,7 +636,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -556,8 +657,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -577,8 +684,14 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,12 +709,23 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading DecisionNode at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -826,6 +950,10 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -842,6 +970,10 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -902,7 +1034,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -926,7 +1065,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -938,7 +1084,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -950,7 +1103,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -962,7 +1122,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -974,7 +1141,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -986,7 +1160,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -998,7 +1179,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1010,7 +1198,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1022,7 +1217,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1034,7 +1236,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1046,7 +1255,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1058,7 +1274,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1072,8 +1295,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1093,8 +1322,14 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1112,12 +1347,23 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading DecisionNode at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs
index 056348dde..5b99b86c8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs
@@ -61,6 +61,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -85,6 +86,7 @@ public class DefinitionReader : XmiDataReader<IDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public DefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DefinitionReader>.Instance : loggerFactory.CreateLogger<DefinitionReader>();
@@ -216,6 +218,10 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -232,6 +238,10 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -294,7 +304,14 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -306,7 +323,14 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +342,14 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +361,14 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -344,8 +382,14 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -365,8 +409,14 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -378,6 +428,10 @@ public override IDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Definition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -512,6 +566,10 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -528,6 +586,10 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -590,7 +652,14 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -602,7 +671,14 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -614,7 +690,14 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -626,7 +709,14 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -640,8 +730,14 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -661,8 +757,14 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -674,6 +776,10 @@ public override async Task<IDefinition> ReadAsync(XmlReader xmiReader, Uri curre
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Definition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs
index 397f6d8f6..f2d478827 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Dependencies;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class DependencyReader : XmiDataReader<IDependency>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public DependencyReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DependencyReader>.Instance : loggerFactory.CreateLogger<DependencyReader>();
@@ -131,6 +133,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             clientXmlAttributeReferences.Add(clientXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'client' on element {ElementId}", clientXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (clientXmlAttributeReferences.Count != 0)
@@ -192,6 +198,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -212,6 +222,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -228,6 +242,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -238,6 +256,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var supplierXmlAttribute = xmiReader.GetAttribute("supplier");
@@ -252,6 +274,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             supplierXmlAttributeReferences.Add(supplierXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'supplier' on element {ElementId}", supplierXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (supplierXmlAttributeReferences.Count != 0)
@@ -286,8 +312,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var clientId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "client", clientId);
+                                        if (Guid.TryParse(hrefSplit[1], out var clientId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "client", clientId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'client' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -341,7 +373,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -353,7 +392,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,8 +413,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -388,8 +440,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -409,8 +467,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -430,8 +494,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -451,8 +521,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var supplierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "supplier", supplierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var supplierId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "supplier", supplierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'supplier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -464,6 +540,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Dependency at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -537,6 +617,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             clientXmlAttributeReferences.Add(clientXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'client' on element {ElementId}", clientXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (clientXmlAttributeReferences.Count != 0)
@@ -598,6 +682,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -618,6 +706,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -634,6 +726,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -644,6 +740,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var supplierXmlAttribute = xmiReader.GetAttribute("supplier");
@@ -658,6 +758,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             supplierXmlAttributeReferences.Add(supplierXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'supplier' on element {ElementId}", supplierXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (supplierXmlAttributeReferences.Count != 0)
@@ -692,8 +796,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var clientId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "client", clientId);
+                                        if (Guid.TryParse(hrefSplit[1], out var clientId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "client", clientId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'client' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -747,7 +857,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -759,7 +876,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -773,8 +897,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -794,8 +924,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -815,8 +951,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -836,8 +978,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -857,8 +1005,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var supplierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "supplier", supplierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var supplierId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "supplier", supplierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'supplier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -870,6 +1024,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Dependency at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs
index ff794622e..9297a3b28 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class DifferencingReader : XmiDataReader<IDifferencing>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public DifferencingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DifferencingReader>.Instance : loggerFactory.CreateLogger<DifferencingReader>();
@@ -141,6 +143,10 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "differencingType", differencingTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'differencingType' on element {ElementId}", differencingTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var elementIdXmlAttribute = xmiReader.GetAttribute("elementId");
@@ -182,6 +188,10 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -202,6 +212,10 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -218,6 +232,10 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -228,6 +246,10 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -280,8 +302,14 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var differencingTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "differencingType", differencingTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var differencingTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "differencingType", differencingTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'differencingType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -311,7 +339,14 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -323,7 +358,14 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -337,8 +379,14 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -358,8 +406,14 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -379,8 +433,14 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,8 +460,14 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -413,6 +479,10 @@ public override IDifferencing Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Differencing at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -496,6 +566,10 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "differencingType", differencingTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'differencingType' on element {ElementId}", differencingTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var elementIdXmlAttribute = xmiReader.GetAttribute("elementId");
@@ -537,6 +611,10 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -557,6 +635,10 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -573,6 +655,10 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -583,6 +669,10 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -635,8 +725,14 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var differencingTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "differencingType", differencingTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var differencingTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "differencingType", differencingTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'differencingType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -666,7 +762,14 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -678,7 +781,14 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -692,8 +802,14 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -713,8 +829,14 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -734,8 +856,14 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -755,8 +883,14 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -768,6 +902,10 @@ public override async Task<IDifferencing> ReadAsync(XmlReader xmiReader, Uri cur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Differencing at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs
index 095a834ac..a235b9a86 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class DisjoiningReader : XmiDataReader<IDisjoining>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public DisjoiningReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DisjoiningReader>.Instance : loggerFactory.CreateLogger<DisjoiningReader>();
@@ -141,6 +143,10 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "disjoiningType", disjoiningTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'disjoiningType' on element {ElementId}", disjoiningTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var elementIdXmlAttribute = xmiReader.GetAttribute("elementId");
@@ -182,6 +188,10 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -202,6 +212,10 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -218,6 +232,10 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -228,6 +246,10 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typeDisjoinedXmlAttribute = xmiReader.GetAttribute("typeDisjoined");
@@ -238,6 +260,10 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typeDisjoined", typeDisjoinedXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'typeDisjoined' on element {ElementId}", typeDisjoinedXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -290,8 +316,14 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var disjoiningTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "disjoiningType", disjoiningTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var disjoiningTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "disjoiningType", disjoiningTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'disjoiningType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -321,7 +353,14 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -333,7 +372,14 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -347,8 +393,14 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -368,8 +420,14 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -389,8 +447,14 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -410,8 +474,14 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -431,8 +501,14 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typeDisjoinedId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typeDisjoined", typeDisjoinedId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typeDisjoinedId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typeDisjoined", typeDisjoinedId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'typeDisjoined' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -444,6 +520,10 @@ public override IDisjoining Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Disjoining at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -527,6 +607,10 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "disjoiningType", disjoiningTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'disjoiningType' on element {ElementId}", disjoiningTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var elementIdXmlAttribute = xmiReader.GetAttribute("elementId");
@@ -568,6 +652,10 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -588,6 +676,10 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -604,6 +696,10 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -614,6 +710,10 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typeDisjoinedXmlAttribute = xmiReader.GetAttribute("typeDisjoined");
@@ -624,6 +724,10 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typeDisjoined", typeDisjoinedXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'typeDisjoined' on element {ElementId}", typeDisjoinedXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -676,8 +780,14 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var disjoiningTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "disjoiningType", disjoiningTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var disjoiningTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "disjoiningType", disjoiningTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'disjoiningType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,7 +817,14 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -719,7 +836,14 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -733,8 +857,14 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -754,8 +884,14 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -775,8 +911,14 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -796,8 +938,14 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -817,8 +965,14 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typeDisjoinedId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typeDisjoined", typeDisjoinedId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typeDisjoinedId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typeDisjoined", typeDisjoinedId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'typeDisjoined' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -830,6 +984,10 @@ public override async Task<IDisjoining> ReadAsync(XmlReader xmiReader, Uri curre
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Disjoining at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs
index b7aae163b..8f0068021 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs
@@ -36,6 +36,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -60,6 +61,7 @@ public class DocumentationReader : XmiDataReader<IDocumentation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public DocumentationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<DocumentationReader>.Instance : loggerFactory.CreateLogger<DocumentationReader>();
@@ -175,6 +177,10 @@ public override IDocumentation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -191,6 +197,10 @@ public override IDocumentation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -265,7 +275,14 @@ public override IDocumentation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -291,8 +308,14 @@ public override IDocumentation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -312,8 +335,14 @@ public override IDocumentation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -325,6 +354,10 @@ public override IDocumentation Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Documentation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -443,6 +476,10 @@ public override async Task<IDocumentation> ReadAsync(XmlReader xmiReader, Uri cu
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -459,6 +496,10 @@ public override async Task<IDocumentation> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -533,7 +574,14 @@ public override async Task<IDocumentation> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -559,8 +607,14 @@ public override async Task<IDocumentation> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -580,8 +634,14 @@ public override async Task<IDocumentation> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -593,6 +653,10 @@ public override async Task<IDocumentation> ReadAsync(XmlReader xmiReader, Uri cu
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Documentation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs
index 8abb0bbc4..d0f42cd7b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Packages;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -63,6 +64,7 @@ public class ElementFilterMembershipReader : XmiDataReader<IElementFilterMembers
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ElementFilterMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ElementFilterMembershipReader>.Instance : loggerFactory.CreateLogger<ElementFilterMembershipReader>();
@@ -174,6 +176,10 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -194,6 +200,10 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -210,6 +220,10 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -220,6 +234,10 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -292,7 +310,14 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -304,7 +329,14 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,8 +350,14 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -339,8 +377,14 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -360,8 +404,14 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -381,8 +431,14 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,12 +456,23 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ElementFilterMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -520,6 +587,10 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -540,6 +611,10 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -556,6 +631,10 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -566,6 +645,10 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -638,7 +721,14 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -650,7 +740,14 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -664,8 +761,14 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -685,8 +788,14 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -706,8 +815,14 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -727,8 +842,14 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -746,12 +867,23 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ElementFilterMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs
index 82c44d161..50f320b4a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -63,6 +64,7 @@ public class EndFeatureMembershipReader : XmiDataReader<IEndFeatureMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public EndFeatureMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<EndFeatureMembershipReader>.Instance : loggerFactory.CreateLogger<EndFeatureMembershipReader>();
@@ -174,6 +176,10 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -194,6 +200,10 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -210,6 +220,10 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -220,6 +234,10 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -292,7 +310,14 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -304,7 +329,14 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,8 +350,14 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -339,8 +377,14 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -360,8 +404,14 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -381,8 +431,14 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,12 +456,23 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading EndFeatureMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -520,6 +587,10 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -540,6 +611,10 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -556,6 +631,10 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -566,6 +645,10 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -638,7 +721,14 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -650,7 +740,14 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -664,8 +761,14 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -685,8 +788,14 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -706,8 +815,14 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -727,8 +842,14 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -746,12 +867,23 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading EndFeatureMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs
index d0908301b..421325384 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs
@@ -61,6 +61,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -85,6 +86,7 @@ public class EnumerationDefinitionReader : XmiDataReader<IEnumerationDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public EnumerationDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<EnumerationDefinitionReader>.Instance : loggerFactory.CreateLogger<EnumerationDefinitionReader>();
@@ -216,6 +218,10 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -232,6 +238,10 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -294,7 +304,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -306,7 +323,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +342,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +361,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -344,8 +382,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -365,8 +409,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -378,6 +428,10 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading EnumerationDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -512,6 +566,10 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -528,6 +586,10 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -590,7 +652,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -602,7 +671,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -614,7 +690,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -626,7 +709,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -640,8 +730,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -661,8 +757,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -674,6 +776,10 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading EnumerationDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs
index 26ab5476c..7bcac1eb3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Enumerations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class EnumerationUsageReader : XmiDataReader<IEnumerationUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public EnumerationUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<EnumerationUsageReader>.Instance : loggerFactory.CreateLogger<EnumerationUsageReader>();
@@ -298,6 +300,10 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -314,6 +320,10 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -364,7 +374,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -388,7 +405,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -400,7 +424,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -412,7 +443,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -424,7 +462,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -436,7 +481,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -448,7 +500,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -460,7 +519,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -472,7 +538,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -484,7 +557,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -496,7 +576,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -508,7 +595,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -522,8 +616,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -543,8 +643,14 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -556,6 +662,10 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading EnumerationUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -770,6 +880,10 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -786,6 +900,10 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -836,7 +954,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -860,7 +985,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -872,7 +1004,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -884,7 +1023,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -896,7 +1042,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -908,7 +1061,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -920,7 +1080,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -932,7 +1099,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -944,7 +1118,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -956,7 +1137,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -968,7 +1156,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -980,7 +1175,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -994,8 +1196,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1015,8 +1223,14 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1028,6 +1242,10 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading EnumerationUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs
index 0ad5a9838..1c9743b6c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -88,6 +89,7 @@ public class EventOccurrenceUsageReader : XmiDataReader<IEventOccurrenceUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public EventOccurrenceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<EventOccurrenceUsageReader>.Instance : loggerFactory.CreateLogger<EventOccurrenceUsageReader>();
@@ -309,6 +311,10 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -325,6 +331,10 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -385,7 +395,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -409,7 +426,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -421,7 +445,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -433,7 +464,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -445,7 +483,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -457,7 +502,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -469,7 +521,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -481,7 +540,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -493,7 +559,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -505,7 +578,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -517,7 +597,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -529,7 +616,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -541,7 +635,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -555,8 +656,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -576,8 +683,14 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -595,12 +708,23 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading EventOccurrenceUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -825,6 +949,10 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -841,6 +969,10 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -901,7 +1033,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -925,7 +1064,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -937,7 +1083,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -949,7 +1102,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -961,7 +1121,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,7 +1140,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -985,7 +1159,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -997,7 +1178,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1009,7 +1197,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1021,7 +1216,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1033,7 +1235,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1045,7 +1254,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1057,7 +1273,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1071,8 +1294,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1092,8 +1321,14 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1111,12 +1346,23 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading EventOccurrenceUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs
index 47590aaea..fb1b60c54 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class ExhibitStateUsageReader : XmiDataReader<IExhibitStateUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ExhibitStateUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ExhibitStateUsageReader>.Instance : loggerFactory.CreateLogger<ExhibitStateUsageReader>();
@@ -320,6 +322,10 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -336,6 +342,10 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -396,7 +406,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -420,7 +437,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -432,7 +456,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -444,7 +475,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -456,7 +494,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -468,7 +513,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -480,7 +532,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -492,7 +551,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -504,7 +570,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -516,7 +589,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isParallelValue))
                                     {
-                                        poco.IsParallel = bool.Parse(isParallelValue);
+                                        if (bool.TryParse(isParallelValue, out var isParallelValueAsBool))
+                                        {
+                                            poco.IsParallel = isParallelValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isParallel' on element {ElementId}", isParallelValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -528,7 +608,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -540,7 +627,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -552,7 +646,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -564,7 +665,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -578,8 +686,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -599,8 +713,14 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -618,12 +738,23 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ExhibitStateUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -858,6 +989,10 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -874,6 +1009,10 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -934,7 +1073,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -958,7 +1104,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -970,7 +1123,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -982,7 +1142,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -994,7 +1161,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1006,7 +1180,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1018,7 +1199,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1030,7 +1218,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1042,7 +1237,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1054,7 +1256,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isParallelValue))
                                     {
-                                        poco.IsParallel = bool.Parse(isParallelValue);
+                                        if (bool.TryParse(isParallelValue, out var isParallelValueAsBool))
+                                        {
+                                            poco.IsParallel = isParallelValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isParallel' on element {ElementId}", isParallelValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1066,7 +1275,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1078,7 +1294,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1090,7 +1313,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1102,7 +1332,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1116,8 +1353,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1137,8 +1380,14 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1156,12 +1405,23 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ExhibitStateUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs
index de3c24505..656307254 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class ExpressionReader : XmiDataReader<IExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ExpressionReader>.Instance : loggerFactory.CreateLogger<ExpressionReader>();
@@ -276,6 +278,10 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -292,6 +298,10 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -342,7 +352,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -366,7 +383,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -378,7 +402,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -390,7 +421,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -402,7 +440,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -414,7 +459,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -426,7 +478,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -438,7 +497,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -450,7 +516,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -462,7 +535,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -474,7 +554,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -486,7 +573,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -500,8 +594,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -521,8 +621,14 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -534,6 +640,10 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Expression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -748,6 +858,10 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -764,6 +878,10 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -814,7 +932,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -838,7 +963,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -850,7 +982,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -862,7 +1001,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -874,7 +1020,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -886,7 +1039,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -898,7 +1058,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -910,7 +1077,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -922,7 +1096,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -934,7 +1115,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -946,7 +1134,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -958,7 +1153,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -972,8 +1174,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -993,8 +1201,14 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1006,6 +1220,10 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Expression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs
index d41c76566..ecd75744f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class FeatureChainExpressionReader : XmiDataReader<IFeatureChainExpressio
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FeatureChainExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureChainExpressionReader>.Instance : loggerFactory.CreateLogger<FeatureChainExpressionReader>();
@@ -284,6 +286,10 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -300,6 +306,10 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -350,7 +360,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -374,7 +391,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -386,7 +410,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -398,7 +429,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +448,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +467,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +486,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +505,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +524,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +543,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +562,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +581,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -520,8 +614,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -541,8 +641,14 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -554,6 +660,10 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureChainExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -775,6 +885,10 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -791,6 +905,10 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -841,7 +959,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -865,7 +990,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -877,7 +1009,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -889,7 +1028,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -901,7 +1047,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -913,7 +1066,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -925,7 +1085,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -937,7 +1104,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -949,7 +1123,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -961,7 +1142,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,7 +1161,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -985,7 +1180,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,8 +1213,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1032,8 +1240,14 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1045,6 +1259,10 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureChainExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs
index aaece05eb..3a76a5dbf 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class FeatureChainingReader : XmiDataReader<IFeatureChaining>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FeatureChainingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureChainingReader>.Instance : loggerFactory.CreateLogger<FeatureChainingReader>();
@@ -127,6 +129,10 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "chainingFeature", chainingFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'chainingFeature' on element {ElementId}", chainingFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -182,6 +188,10 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -202,6 +212,10 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -218,6 +232,10 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -228,6 +246,10 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -256,8 +278,14 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var chainingFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "chainingFeature", chainingFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var chainingFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "chainingFeature", chainingFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'chainingFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -311,7 +339,14 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -323,7 +358,14 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -337,8 +379,14 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -358,8 +406,14 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -379,8 +433,14 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,8 +460,14 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -413,6 +479,10 @@ public override IFeatureChaining Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureChaining at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -482,6 +552,10 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "chainingFeature", chainingFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'chainingFeature' on element {ElementId}", chainingFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -537,6 +611,10 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -557,6 +635,10 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -573,6 +655,10 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -583,6 +669,10 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -611,8 +701,14 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var chainingFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "chainingFeature", chainingFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var chainingFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "chainingFeature", chainingFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'chainingFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -666,7 +762,14 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -678,7 +781,14 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -692,8 +802,14 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -713,8 +829,14 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -734,8 +856,14 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -755,8 +883,14 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -768,6 +902,10 @@ public override async Task<IFeatureChaining> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureChaining at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs
index 2309960ac..2b515ff18 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class FeatureInvertingReader : XmiDataReader<IFeatureInverting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FeatureInvertingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureInvertingReader>.Instance : loggerFactory.CreateLogger<FeatureInvertingReader>();
@@ -148,6 +150,10 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureInverted", featureInvertedXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'featureInverted' on element {ElementId}", featureInvertedXmlAttribute, poco.Id);
+                    }
                 }
 
                 var invertingFeatureXmlAttribute = xmiReader.GetAttribute("invertingFeature");
@@ -158,6 +164,10 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "invertingFeature", invertingFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'invertingFeature' on element {ElementId}", invertingFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -192,6 +202,10 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -212,6 +226,10 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -228,6 +246,10 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -238,6 +260,10 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -302,8 +328,14 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var featureInvertedId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureInverted", featureInvertedId);
+                                        if (Guid.TryParse(hrefSplit[1], out var featureInvertedId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureInverted", featureInvertedId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'featureInverted' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -323,8 +355,14 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var invertingFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "invertingFeature", invertingFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var invertingFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "invertingFeature", invertingFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'invertingFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -342,7 +380,14 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -354,7 +399,14 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -368,8 +420,14 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -389,8 +447,14 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -410,8 +474,14 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -431,8 +501,14 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -444,6 +520,10 @@ public override IFeatureInverting Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureInverting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -534,6 +614,10 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureInverted", featureInvertedXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'featureInverted' on element {ElementId}", featureInvertedXmlAttribute, poco.Id);
+                    }
                 }
 
                 var invertingFeatureXmlAttribute = xmiReader.GetAttribute("invertingFeature");
@@ -544,6 +628,10 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "invertingFeature", invertingFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'invertingFeature' on element {ElementId}", invertingFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -578,6 +666,10 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -598,6 +690,10 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -614,6 +710,10 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -624,6 +724,10 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -688,8 +792,14 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var featureInvertedId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureInverted", featureInvertedId);
+                                        if (Guid.TryParse(hrefSplit[1], out var featureInvertedId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureInverted", featureInvertedId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'featureInverted' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -709,8 +819,14 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var invertingFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "invertingFeature", invertingFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var invertingFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "invertingFeature", invertingFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'invertingFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -728,7 +844,14 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -740,7 +863,14 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -754,8 +884,14 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -775,8 +911,14 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -796,8 +938,14 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -817,8 +965,14 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -830,6 +984,10 @@ public override async Task<IFeatureInverting> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureInverting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs
index 76ddfe139..7c7a6b160 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -63,6 +64,7 @@ public class FeatureMembershipReader : XmiDataReader<IFeatureMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FeatureMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureMembershipReader>.Instance : loggerFactory.CreateLogger<FeatureMembershipReader>();
@@ -174,6 +176,10 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -194,6 +200,10 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -210,6 +220,10 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -220,6 +234,10 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -292,7 +310,14 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -304,7 +329,14 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,8 +350,14 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -339,8 +377,14 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -360,8 +404,14 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -381,8 +431,14 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,12 +456,23 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -520,6 +587,10 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -540,6 +611,10 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -556,6 +631,10 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -566,6 +645,10 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -638,7 +721,14 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -650,7 +740,14 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -664,8 +761,14 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -685,8 +788,14 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -706,8 +815,14 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -727,8 +842,14 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -746,12 +867,23 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs
index 9373f8739..d7699caf7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -63,6 +64,7 @@ public class FeatureReader : XmiDataReader<IFeature>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureReader>.Instance : loggerFactory.CreateLogger<FeatureReader>();
@@ -274,6 +276,10 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -290,6 +296,10 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -340,7 +350,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -364,7 +381,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -376,7 +400,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -388,7 +419,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -400,7 +438,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -412,7 +457,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -424,7 +476,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -436,7 +495,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -448,7 +514,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -460,7 +533,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -472,7 +552,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -484,7 +571,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -498,8 +592,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -519,8 +619,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -532,6 +638,10 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Feature at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -746,6 +856,10 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -762,6 +876,10 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -812,7 +930,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -836,7 +961,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -848,7 +980,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -860,7 +999,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -872,7 +1018,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -884,7 +1037,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -896,7 +1056,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -908,7 +1075,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -920,7 +1094,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -932,7 +1113,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -944,7 +1132,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -956,7 +1151,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -970,8 +1172,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -991,8 +1199,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1004,6 +1218,10 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Feature at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs
index da373fcfe..e60224916 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class FeatureReferenceExpressionReader : XmiDataReader<IFeatureReferenceE
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FeatureReferenceExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureReferenceExpressionReader>.Instance : loggerFactory.CreateLogger<FeatureReferenceExpressionReader>();
@@ -277,6 +279,10 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -343,7 +353,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,7 +384,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -379,7 +403,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,7 +422,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -403,7 +441,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -415,7 +460,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -427,7 +479,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -439,7 +498,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -451,7 +517,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -463,7 +536,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -475,7 +555,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -487,7 +574,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,8 +595,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -522,8 +622,14 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -535,6 +641,10 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureReferenceExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -749,6 +859,10 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -765,6 +879,10 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -815,7 +933,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -839,7 +964,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -851,7 +983,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -863,7 +1002,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -875,7 +1021,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -887,7 +1040,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -899,7 +1059,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -911,7 +1078,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -923,7 +1097,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -935,7 +1116,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -947,7 +1135,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -959,7 +1154,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,8 +1175,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -994,8 +1202,14 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1007,6 +1221,10 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureReferenceExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs
index 45b598bb7..2005e0ac6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class FeatureTypingReader : XmiDataReader<IFeatureTyping>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FeatureTypingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureTypingReader>.Instance : loggerFactory.CreateLogger<FeatureTypingReader>();
@@ -173,6 +175,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -193,6 +199,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -209,6 +219,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -219,6 +233,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typeXmlAttribute = xmiReader.GetAttribute("type");
@@ -229,6 +247,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'type' on element {ElementId}", typeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typedFeatureXmlAttribute = xmiReader.GetAttribute("typedFeature");
@@ -239,6 +261,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'typedFeature' on element {ElementId}", typedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -301,7 +327,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -313,7 +346,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -327,8 +367,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -348,8 +394,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -369,8 +421,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -390,8 +448,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -411,8 +475,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'type' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -432,8 +502,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'typedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -445,6 +521,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureTyping at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -559,6 +639,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -579,6 +663,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -595,6 +683,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -605,6 +697,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typeXmlAttribute = xmiReader.GetAttribute("type");
@@ -615,6 +711,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'type' on element {ElementId}", typeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typedFeatureXmlAttribute = xmiReader.GetAttribute("typedFeature");
@@ -625,6 +725,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'typedFeature' on element {ElementId}", typedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -687,7 +791,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -699,7 +810,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -713,8 +831,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -734,8 +858,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -755,8 +885,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -776,8 +912,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -797,8 +939,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'type' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -818,8 +966,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'typedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -831,6 +985,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureTyping at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs
index e1c48ca1b..edffc0280 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.FeatureValues;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class FeatureValueReader : XmiDataReader<IFeatureValue>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FeatureValueReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FeatureValueReader>.Instance : loggerFactory.CreateLogger<FeatureValueReader>();
@@ -195,6 +197,10 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -215,6 +221,10 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -231,6 +241,10 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -241,6 +255,10 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -313,7 +331,14 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDefaultValue))
                                     {
-                                        poco.IsDefault = bool.Parse(isDefaultValue);
+                                        if (bool.TryParse(isDefaultValue, out var isDefaultValueAsBool))
+                                        {
+                                            poco.IsDefault = isDefaultValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDefault' on element {ElementId}", isDefaultValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -325,7 +350,14 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -337,7 +369,14 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -349,7 +388,14 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isInitialValue))
                                     {
-                                        poco.IsInitial = bool.Parse(isInitialValue);
+                                        if (bool.TryParse(isInitialValue, out var isInitialValueAsBool))
+                                        {
+                                            poco.IsInitial = isInitialValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isInitial' on element {ElementId}", isInitialValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -363,8 +409,14 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -384,8 +436,14 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -405,8 +463,14 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -426,8 +490,14 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -445,12 +515,23 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureValue at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -585,6 +666,10 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -605,6 +690,10 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -621,6 +710,10 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -631,6 +724,10 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -703,7 +800,14 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isDefaultValue))
                                     {
-                                        poco.IsDefault = bool.Parse(isDefaultValue);
+                                        if (bool.TryParse(isDefaultValue, out var isDefaultValueAsBool))
+                                        {
+                                            poco.IsDefault = isDefaultValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDefault' on element {ElementId}", isDefaultValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -715,7 +819,14 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -727,7 +838,14 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -739,7 +857,14 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isInitialValue))
                                     {
-                                        poco.IsInitial = bool.Parse(isInitialValue);
+                                        if (bool.TryParse(isInitialValue, out var isInitialValueAsBool))
+                                        {
+                                            poco.IsInitial = isInitialValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isInitial' on element {ElementId}", isInitialValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -753,8 +878,14 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -774,8 +905,14 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -795,8 +932,14 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -816,8 +959,14 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -835,12 +984,23 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureValue at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs
index 59e97e23d..a441570cc 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -88,6 +89,7 @@ public class FlowDefinitionReader : XmiDataReader<IFlowDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FlowDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FlowDefinitionReader>.Instance : loggerFactory.CreateLogger<FlowDefinitionReader>();
@@ -239,6 +241,10 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -259,6 +265,10 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -275,6 +285,10 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -285,6 +299,10 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -347,7 +365,14 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -359,7 +384,14 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -371,7 +403,14 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -383,7 +422,14 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -395,7 +441,14 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -407,7 +460,14 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -421,8 +481,14 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -442,8 +508,14 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -463,8 +535,14 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -484,8 +562,14 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -497,6 +581,10 @@ public override IFlowDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FlowDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -651,6 +739,10 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -671,6 +763,10 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -687,6 +783,10 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -697,6 +797,10 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -759,7 +863,14 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -771,7 +882,14 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -783,7 +901,14 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -795,7 +920,14 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -807,7 +939,14 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -819,7 +958,14 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -833,8 +979,14 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -854,8 +1006,14 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -875,8 +1033,14 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -896,8 +1060,14 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -909,6 +1079,10 @@ public override async Task<IFlowDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FlowDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs
index 937fb9502..3cd6a7613 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class FlowEndReader : XmiDataReader<IFlowEnd>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FlowEndReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FlowEndReader>.Instance : loggerFactory.CreateLogger<FlowEndReader>();
@@ -275,6 +277,10 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -291,6 +297,10 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -341,7 +351,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -365,7 +382,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -377,7 +401,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -389,7 +420,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -401,7 +439,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -413,7 +458,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -425,7 +477,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -437,7 +496,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -449,7 +515,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -461,7 +534,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -473,7 +553,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,7 +572,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -499,8 +593,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -520,8 +620,14 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -533,6 +639,10 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FlowEnd at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -747,6 +857,10 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -763,6 +877,10 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -813,7 +931,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -837,7 +962,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -849,7 +981,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -861,7 +1000,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -873,7 +1019,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -885,7 +1038,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -897,7 +1057,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -909,7 +1076,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -921,7 +1095,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -933,7 +1114,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -945,7 +1133,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -957,7 +1152,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -971,8 +1173,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -992,8 +1200,14 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1005,6 +1219,10 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FlowEnd at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs
index 68f1f66ae..1f0e17d83 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -68,6 +69,7 @@ public class FlowReader : XmiDataReader<IFlow>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FlowReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FlowReader>.Instance : loggerFactory.CreateLogger<FlowReader>();
@@ -289,6 +291,10 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -309,6 +315,10 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -325,6 +335,10 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -335,6 +349,10 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -385,7 +403,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -409,7 +434,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -421,7 +453,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -433,7 +472,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -445,7 +491,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -457,7 +510,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -469,7 +529,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -481,7 +548,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -493,7 +567,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -505,7 +586,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -517,7 +605,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -529,7 +624,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -541,7 +643,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -555,8 +664,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -576,8 +691,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,8 +718,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -618,8 +745,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -631,6 +764,10 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Flow at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -855,6 +992,10 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -875,6 +1016,10 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -891,6 +1036,10 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -901,6 +1050,10 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -951,7 +1104,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1135,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1154,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1173,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1192,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1211,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1230,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1249,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1268,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1071,7 +1287,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1083,7 +1306,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1095,7 +1325,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1107,7 +1344,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1121,8 +1365,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1142,8 +1392,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1163,8 +1419,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1184,8 +1446,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1197,6 +1465,10 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Flow at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs
index 631801be2..58ed9d56c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -92,6 +93,7 @@ public class FlowUsageReader : XmiDataReader<IFlowUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FlowUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FlowUsageReader>.Instance : loggerFactory.CreateLogger<FlowUsageReader>();
@@ -323,6 +325,10 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -343,6 +349,10 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -359,6 +369,10 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -369,6 +383,10 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -429,7 +447,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -453,7 +478,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -465,7 +497,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -477,7 +516,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -489,7 +535,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,7 +554,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -513,7 +573,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -525,7 +592,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -537,7 +611,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -549,7 +630,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -561,7 +649,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -573,7 +668,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -585,7 +687,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -597,7 +706,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -611,8 +727,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -632,8 +754,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -653,8 +781,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -674,8 +808,14 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -693,12 +833,23 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FlowUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -933,6 +1084,10 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -953,6 +1108,10 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -969,6 +1128,10 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -979,6 +1142,10 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -1039,7 +1206,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1063,7 +1237,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1075,7 +1256,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1087,7 +1275,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1099,7 +1294,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1111,7 +1313,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1123,7 +1332,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1135,7 +1351,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1147,7 +1370,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1159,7 +1389,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1171,7 +1408,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1183,7 +1427,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1195,7 +1446,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1207,7 +1465,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1221,8 +1486,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1242,8 +1513,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1263,8 +1540,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1284,8 +1567,14 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1303,12 +1592,23 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FlowUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs
index 0846e60bd..2e000c3ff 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class ForLoopActionUsageReader : XmiDataReader<IForLoopActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ForLoopActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ForLoopActionUsageReader>.Instance : loggerFactory.CreateLogger<ForLoopActionUsageReader>();
@@ -311,6 +313,10 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ForLoopActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ForLoopActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs
index 388c4d705..cb0ed0e26 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class ForkNodeReader : XmiDataReader<IForkNode>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ForkNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ForkNodeReader>.Instance : loggerFactory.CreateLogger<ForkNodeReader>();
@@ -310,6 +312,10 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -326,6 +332,10 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -386,7 +396,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +427,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +446,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +465,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +484,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +503,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +522,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +541,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +560,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -506,7 +579,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -518,7 +598,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -530,7 +617,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -542,7 +636,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -556,8 +657,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -577,8 +684,14 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,12 +709,23 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ForkNode at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -826,6 +950,10 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -842,6 +970,10 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -902,7 +1034,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -926,7 +1065,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -938,7 +1084,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -950,7 +1103,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -962,7 +1122,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -974,7 +1141,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -986,7 +1160,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -998,7 +1179,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1010,7 +1198,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1022,7 +1217,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1034,7 +1236,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1046,7 +1255,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1058,7 +1274,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1072,8 +1295,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1093,8 +1322,14 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1112,12 +1347,23 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ForkNode at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs
index e1c07f8a0..fd79eed39 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Constraints;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class FramedConcernMembershipReader : XmiDataReader<IFramedConcernMembers
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FramedConcernMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FramedConcernMembershipReader>.Instance : loggerFactory.CreateLogger<FramedConcernMembershipReader>();
@@ -187,6 +189,10 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -207,6 +213,10 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -223,6 +233,10 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -233,6 +247,10 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -305,7 +323,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +342,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +361,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (RequirementConstraintKind)Enum.Parse(typeof(RequirementConstraintKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -343,8 +382,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -364,8 +409,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -385,8 +436,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -406,8 +463,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -425,12 +488,23 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FramedConcernMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -555,6 +629,10 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -575,6 +653,10 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -591,6 +673,10 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -601,6 +687,10 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -673,7 +763,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,7 +782,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -697,7 +801,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (RequirementConstraintKind)Enum.Parse(typeof(RequirementConstraintKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -711,8 +822,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -732,8 +849,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -753,8 +876,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -774,8 +903,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -793,12 +928,23 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FramedConcernMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs
index ac75412bb..e9295a3e4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class FunctionReader : XmiDataReader<IFunction>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public FunctionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<FunctionReader>.Instance : loggerFactory.CreateLogger<FunctionReader>();
@@ -186,6 +188,10 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -202,6 +208,10 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -264,7 +274,14 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -276,7 +293,14 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -288,7 +312,14 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -302,8 +333,14 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -323,8 +360,14 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -336,6 +379,10 @@ public override IFunction Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Function at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -460,6 +507,10 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -476,6 +527,10 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -538,7 +593,14 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -550,7 +612,14 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -562,7 +631,14 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -576,8 +652,14 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,8 +679,14 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -610,6 +698,10 @@ public override async Task<IFunction> ReadAsync(XmlReader xmiReader, Uri current
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Function at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs
index 67811e63a..9cf58ac01 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class IfActionUsageReader : XmiDataReader<IIfActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public IfActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<IfActionUsageReader>.Instance : loggerFactory.CreateLogger<IfActionUsageReader>();
@@ -311,6 +313,10 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading IfActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading IfActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs
index 0599268f6..c290de834 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class IncludeUseCaseUsageReader : XmiDataReader<IIncludeUseCaseUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public IncludeUseCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<IncludeUseCaseUsageReader>.Instance : loggerFactory.CreateLogger<IncludeUseCaseUsageReader>();
@@ -311,6 +313,10 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading IncludeUseCaseUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading IncludeUseCaseUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs
index d5b4c8f0e..08af86790 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class IndexExpressionReader : XmiDataReader<IIndexExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public IndexExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<IndexExpressionReader>.Instance : loggerFactory.CreateLogger<IndexExpressionReader>();
@@ -284,6 +286,10 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -300,6 +306,10 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -350,7 +360,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -374,7 +391,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -386,7 +410,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -398,7 +429,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +448,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +467,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +486,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +505,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +524,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +543,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +562,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +581,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -520,8 +614,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -541,8 +641,14 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -554,6 +660,10 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading IndexExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -775,6 +885,10 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -791,6 +905,10 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -841,7 +959,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -865,7 +990,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -877,7 +1009,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -889,7 +1028,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -901,7 +1047,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -913,7 +1066,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -925,7 +1085,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -937,7 +1104,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -949,7 +1123,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -961,7 +1142,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,7 +1161,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -985,7 +1180,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,8 +1213,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1032,8 +1240,14 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1045,6 +1259,10 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading IndexExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs
index f92062ac9..66a84930d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class InteractionReader : XmiDataReader<IInteraction>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public InteractionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<InteractionReader>.Instance : loggerFactory.CreateLogger<InteractionReader>();
@@ -197,6 +199,10 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -217,6 +223,10 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -233,6 +243,10 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -243,6 +257,10 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -305,7 +323,14 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +342,14 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +361,14 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -341,7 +380,14 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -355,8 +401,14 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -376,8 +428,14 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -397,8 +455,14 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -418,8 +482,14 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -431,6 +501,10 @@ public override IInteraction Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Interaction at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -565,6 +639,10 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -585,6 +663,10 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -601,6 +683,10 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -611,6 +697,10 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -673,7 +763,14 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,7 +782,14 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -697,7 +801,14 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -709,7 +820,14 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -723,8 +841,14 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -744,8 +868,14 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -765,8 +895,14 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -786,8 +922,14 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -799,6 +941,10 @@ public override async Task<IInteraction> ReadAsync(XmlReader xmiReader, Uri curr
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Interaction at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs
index 98de4139d..fdb953a87 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class InterfaceDefinitionReader : XmiDataReader<IInterfaceDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public InterfaceDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<InterfaceDefinitionReader>.Instance : loggerFactory.CreateLogger<InterfaceDefinitionReader>();
@@ -237,6 +239,10 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -257,6 +263,10 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -273,6 +283,10 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -283,6 +297,10 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -345,7 +363,14 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -357,7 +382,14 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -369,7 +401,14 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -381,7 +420,14 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -393,7 +439,14 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -405,7 +458,14 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -419,8 +479,14 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -440,8 +506,14 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -461,8 +533,14 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -482,8 +560,14 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -495,6 +579,10 @@ public override IInterfaceDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading InterfaceDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -649,6 +737,10 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -669,6 +761,10 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -685,6 +781,10 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -695,6 +795,10 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -757,7 +861,14 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -769,7 +880,14 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -781,7 +899,14 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -793,7 +918,14 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -805,7 +937,14 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -817,7 +956,14 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -831,8 +977,14 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -852,8 +1004,14 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -873,8 +1031,14 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -894,8 +1058,14 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -907,6 +1077,10 @@ public override async Task<IInterfaceDefinition> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading InterfaceDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs
index 8189fb2fc..5a344777f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Interfaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -91,6 +92,7 @@ public class InterfaceUsageReader : XmiDataReader<IInterfaceUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public InterfaceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<InterfaceUsageReader>.Instance : loggerFactory.CreateLogger<InterfaceUsageReader>();
@@ -322,6 +324,10 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -342,6 +348,10 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -358,6 +368,10 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -368,6 +382,10 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -428,7 +446,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -452,7 +477,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -464,7 +496,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -476,7 +515,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -488,7 +534,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -500,7 +553,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -512,7 +572,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -524,7 +591,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -536,7 +610,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -548,7 +629,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -560,7 +648,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -572,7 +667,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -584,7 +686,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -596,7 +705,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -610,8 +726,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -631,8 +753,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -652,8 +780,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -673,8 +807,14 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -692,12 +832,23 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading InterfaceUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -932,6 +1083,10 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -952,6 +1107,10 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -968,6 +1127,10 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -978,6 +1141,10 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -1038,7 +1205,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1062,7 +1236,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1074,7 +1255,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1086,7 +1274,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1098,7 +1293,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1110,7 +1312,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1122,7 +1331,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1134,7 +1350,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1146,7 +1369,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1158,7 +1388,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1170,7 +1407,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1182,7 +1426,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1194,7 +1445,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1206,7 +1464,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1220,8 +1485,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1241,8 +1512,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1262,8 +1539,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1283,8 +1566,14 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1302,12 +1591,23 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading InterfaceUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs
index ea29fba2a..f75e35193 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class IntersectingReader : XmiDataReader<IIntersecting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public IntersectingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<IntersectingReader>.Instance : loggerFactory.CreateLogger<IntersectingReader>();
@@ -148,6 +150,10 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "intersectingType", intersectingTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'intersectingType' on element {ElementId}", intersectingTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -182,6 +188,10 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -202,6 +212,10 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -218,6 +232,10 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -228,6 +246,10 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -292,8 +314,14 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var intersectingTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "intersectingType", intersectingTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var intersectingTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "intersectingType", intersectingTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'intersectingType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -311,7 +339,14 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -323,7 +358,14 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -337,8 +379,14 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -358,8 +406,14 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -379,8 +433,14 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,8 +460,14 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -413,6 +479,10 @@ public override IIntersecting Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Intersecting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -503,6 +573,10 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "intersectingType", intersectingTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'intersectingType' on element {ElementId}", intersectingTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -537,6 +611,10 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -557,6 +635,10 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -573,6 +655,10 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -583,6 +669,10 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -647,8 +737,14 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var intersectingTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "intersectingType", intersectingTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var intersectingTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "intersectingType", intersectingTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'intersectingType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -666,7 +762,14 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -678,7 +781,14 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -692,8 +802,14 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -713,8 +829,14 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -734,8 +856,14 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -755,8 +883,14 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -768,6 +902,10 @@ public override async Task<IIntersecting> ReadAsync(XmlReader xmiReader, Uri cur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Intersecting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs
index 6f4dda851..b2d43e44d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class InvariantReader : XmiDataReader<IInvariant>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public InvariantReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<InvariantReader>.Instance : loggerFactory.CreateLogger<InvariantReader>();
@@ -286,6 +288,10 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -302,6 +308,10 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -352,7 +362,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -376,7 +393,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -388,7 +412,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -400,7 +431,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -412,7 +450,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -424,7 +469,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -436,7 +488,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -448,7 +507,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isNegatedValue))
                                     {
-                                        poco.IsNegated = bool.Parse(isNegatedValue);
+                                        if (bool.TryParse(isNegatedValue, out var isNegatedValueAsBool))
+                                        {
+                                            poco.IsNegated = isNegatedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isNegated' on element {ElementId}", isNegatedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -460,7 +526,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -472,7 +545,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -484,7 +564,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -496,7 +583,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -508,7 +602,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -522,8 +623,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -543,8 +650,14 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -556,6 +669,10 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Invariant at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -780,6 +897,10 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -796,6 +917,10 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -846,7 +971,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -870,7 +1002,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -882,7 +1021,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -894,7 +1040,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -906,7 +1059,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -918,7 +1078,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -930,7 +1097,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -942,7 +1116,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isNegatedValue))
                                     {
-                                        poco.IsNegated = bool.Parse(isNegatedValue);
+                                        if (bool.TryParse(isNegatedValue, out var isNegatedValueAsBool))
+                                        {
+                                            poco.IsNegated = isNegatedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isNegated' on element {ElementId}", isNegatedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -954,7 +1135,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -966,7 +1154,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -978,7 +1173,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -990,7 +1192,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1002,7 +1211,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1016,8 +1232,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1037,8 +1259,14 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1050,6 +1278,10 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Invariant at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs
index 7a2e0728e..92ff27f2d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class InvocationExpressionReader : XmiDataReader<IInvocationExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public InvocationExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<InvocationExpressionReader>.Instance : loggerFactory.CreateLogger<InvocationExpressionReader>();
@@ -277,6 +279,10 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -343,7 +353,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,7 +384,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -379,7 +403,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,7 +422,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -403,7 +441,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -415,7 +460,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -427,7 +479,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -439,7 +498,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -451,7 +517,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -463,7 +536,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -475,7 +555,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -487,7 +574,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,8 +595,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -522,8 +622,14 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -535,6 +641,10 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading InvocationExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -749,6 +859,10 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -765,6 +879,10 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -815,7 +933,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -839,7 +964,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -851,7 +983,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -863,7 +1002,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -875,7 +1021,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -887,7 +1040,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -899,7 +1059,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -911,7 +1078,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -923,7 +1097,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -935,7 +1116,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -947,7 +1135,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -959,7 +1154,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,8 +1175,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -994,8 +1202,14 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1007,6 +1221,10 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading InvocationExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs
index e70f7ed2d..c6cf0d4c5 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class ItemDefinitionReader : XmiDataReader<IItemDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ItemDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ItemDefinitionReader>.Instance : loggerFactory.CreateLogger<ItemDefinitionReader>();
@@ -227,6 +229,10 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -243,6 +249,10 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -305,7 +315,14 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +334,14 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +353,14 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -341,7 +372,14 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -353,7 +391,14 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,8 +412,14 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -388,8 +439,14 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,6 +458,10 @@ public override IItemDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ItemDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -545,6 +606,10 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -561,6 +626,10 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -623,7 +692,14 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -635,7 +711,14 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -647,7 +730,14 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -659,7 +749,14 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -671,7 +768,14 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,8 +789,14 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -706,8 +816,14 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -719,6 +835,10 @@ public override async Task<IItemDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ItemDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs
index 8c9eba247..df5a9f91f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Items;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class ItemUsageReader : XmiDataReader<IItemUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ItemUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ItemUsageReader>.Instance : loggerFactory.CreateLogger<ItemUsageReader>();
@@ -310,6 +312,10 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -326,6 +332,10 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -386,7 +396,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +427,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +446,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +465,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +484,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +503,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +522,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +541,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +560,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -506,7 +579,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -518,7 +598,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -530,7 +617,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -542,7 +636,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -556,8 +657,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -577,8 +684,14 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,12 +709,23 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ItemUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -826,6 +950,10 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -842,6 +970,10 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -902,7 +1034,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -926,7 +1065,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -938,7 +1084,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -950,7 +1103,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -962,7 +1122,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -974,7 +1141,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -986,7 +1160,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -998,7 +1179,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1010,7 +1198,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1022,7 +1217,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1034,7 +1236,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1046,7 +1255,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1058,7 +1274,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1072,8 +1295,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1093,8 +1322,14 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1112,12 +1347,23 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ItemUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs
index 4dde20261..c4ee6bb6e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class JoinNodeReader : XmiDataReader<IJoinNode>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public JoinNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<JoinNodeReader>.Instance : loggerFactory.CreateLogger<JoinNodeReader>();
@@ -310,6 +312,10 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -326,6 +332,10 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -386,7 +396,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +427,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +446,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +465,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +484,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +503,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +522,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +541,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +560,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -506,7 +579,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -518,7 +598,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -530,7 +617,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -542,7 +636,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -556,8 +657,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -577,8 +684,14 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,12 +709,23 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading JoinNode at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -826,6 +950,10 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -842,6 +970,10 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -902,7 +1034,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -926,7 +1065,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -938,7 +1084,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -950,7 +1103,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -962,7 +1122,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -974,7 +1141,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -986,7 +1160,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -998,7 +1179,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1010,7 +1198,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1022,7 +1217,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1034,7 +1236,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1046,7 +1255,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1058,7 +1274,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1072,8 +1295,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1093,8 +1322,14 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1112,12 +1347,23 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading JoinNode at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs
index 09e6ca57a..83c058c3a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Packages;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class LibraryPackageReader : XmiDataReader<ILibraryPackage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public LibraryPackageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LibraryPackageReader>.Instance : loggerFactory.CreateLogger<LibraryPackageReader>();
@@ -173,6 +175,10 @@ public override ILibraryPackage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -189,6 +195,10 @@ public override ILibraryPackage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -251,7 +261,14 @@ public override ILibraryPackage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -263,7 +280,14 @@ public override ILibraryPackage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isStandardValue))
                                     {
-                                        poco.IsStandard = bool.Parse(isStandardValue);
+                                        if (bool.TryParse(isStandardValue, out var isStandardValueAsBool))
+                                        {
+                                            poco.IsStandard = isStandardValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isStandard' on element {ElementId}", isStandardValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -277,8 +301,14 @@ public override ILibraryPackage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -298,8 +328,14 @@ public override ILibraryPackage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -311,6 +347,10 @@ public override ILibraryPackage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LibraryPackage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -425,6 +465,10 @@ public override async Task<ILibraryPackage> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -441,6 +485,10 @@ public override async Task<ILibraryPackage> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -503,7 +551,14 @@ public override async Task<ILibraryPackage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -515,7 +570,14 @@ public override async Task<ILibraryPackage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isStandardValue))
                                     {
-                                        poco.IsStandard = bool.Parse(isStandardValue);
+                                        if (bool.TryParse(isStandardValue, out var isStandardValueAsBool))
+                                        {
+                                            poco.IsStandard = isStandardValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isStandard' on element {ElementId}", isStandardValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -529,8 +591,14 @@ public override async Task<ILibraryPackage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -550,8 +618,14 @@ public override async Task<ILibraryPackage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -563,6 +637,10 @@ public override async Task<ILibraryPackage> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LibraryPackage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs
index b250c703e..ae5edfc7a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class LiteralBooleanReader : XmiDataReader<ILiteralBoolean>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public LiteralBooleanReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralBooleanReader>.Instance : loggerFactory.CreateLogger<LiteralBooleanReader>();
@@ -277,6 +279,10 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -353,7 +363,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -377,7 +394,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -389,7 +413,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -401,7 +432,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -413,7 +451,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -425,7 +470,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -437,7 +489,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -449,7 +508,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -461,7 +527,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -473,7 +546,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,7 +565,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -497,7 +584,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -511,8 +605,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -532,8 +632,14 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -551,12 +657,23 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(valueValue))
                                     {
-                                        poco.Value = bool.Parse(valueValue);
+                                        if (bool.TryParse(valueValue, out var valueValueAsBool))
+                                        {
+                                            poco.Value = valueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'value' on element {ElementId}", valueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralBoolean at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -771,6 +888,10 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -787,6 +908,10 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -847,7 +972,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -871,7 +1003,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -883,7 +1022,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -895,7 +1041,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -907,7 +1060,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -919,7 +1079,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -931,7 +1098,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -943,7 +1117,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -955,7 +1136,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -967,7 +1155,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -979,7 +1174,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -991,7 +1193,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1005,8 +1214,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1026,8 +1241,14 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1045,12 +1266,23 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(valueValue))
                                     {
-                                        poco.Value = bool.Parse(valueValue);
+                                        if (bool.TryParse(valueValue, out var valueValueAsBool))
+                                        {
+                                            poco.Value = valueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'value' on element {ElementId}", valueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralBoolean at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs
index eeb6ca8d6..c9cff71ab 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class LiteralExpressionReader : XmiDataReader<ILiteralExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public LiteralExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralExpressionReader>.Instance : loggerFactory.CreateLogger<LiteralExpressionReader>();
@@ -277,6 +279,10 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -343,7 +353,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,7 +384,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -379,7 +403,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,7 +422,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -403,7 +441,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -415,7 +460,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -427,7 +479,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -439,7 +498,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -451,7 +517,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -463,7 +536,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -475,7 +555,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -487,7 +574,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,8 +595,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -522,8 +622,14 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -535,6 +641,10 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -749,6 +859,10 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -765,6 +879,10 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -815,7 +933,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -839,7 +964,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -851,7 +983,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -863,7 +1002,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -875,7 +1021,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -887,7 +1040,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -899,7 +1059,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -911,7 +1078,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -923,7 +1097,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -935,7 +1116,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -947,7 +1135,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -959,7 +1154,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,8 +1175,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -994,8 +1202,14 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1007,6 +1221,10 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs
index 8bd5913fc..61e2da02e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class LiteralInfinityReader : XmiDataReader<ILiteralInfinity>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public LiteralInfinityReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralInfinityReader>.Instance : loggerFactory.CreateLogger<LiteralInfinityReader>();
@@ -277,6 +279,10 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -343,7 +353,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,7 +384,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -379,7 +403,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,7 +422,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -403,7 +441,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -415,7 +460,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -427,7 +479,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -439,7 +498,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -451,7 +517,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -463,7 +536,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -475,7 +555,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -487,7 +574,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,8 +595,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -522,8 +622,14 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -535,6 +641,10 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralInfinity at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -749,6 +859,10 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -765,6 +879,10 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -815,7 +933,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -839,7 +964,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -851,7 +983,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -863,7 +1002,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -875,7 +1021,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -887,7 +1040,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -899,7 +1059,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -911,7 +1078,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -923,7 +1097,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -935,7 +1116,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -947,7 +1135,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -959,7 +1154,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,8 +1175,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -994,8 +1202,14 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1007,6 +1221,10 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralInfinity at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs
index 80e2d97f7..5a5e91090 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class LiteralIntegerReader : XmiDataReader<ILiteralInteger>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public LiteralIntegerReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralIntegerReader>.Instance : loggerFactory.CreateLogger<LiteralIntegerReader>();
@@ -277,6 +279,10 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -353,7 +363,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -377,7 +394,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -389,7 +413,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -401,7 +432,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -413,7 +451,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -425,7 +470,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -437,7 +489,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -449,7 +508,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -461,7 +527,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -473,7 +546,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,7 +565,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -497,7 +584,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -511,8 +605,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -532,8 +632,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -551,12 +657,23 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(valueValue))
                                     {
-                                        poco.Value = int.Parse(valueValue);
+                                        if (int.TryParse(valueValue, out var valueValueAsInt))
+                                        {
+                                            poco.Value = valueValueAsInt;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse int value '{Value}' for property 'value' on element {ElementId}", valueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralInteger at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -771,6 +888,10 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -787,6 +908,10 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -847,7 +972,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -871,7 +1003,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -883,7 +1022,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -895,7 +1041,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -907,7 +1060,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -919,7 +1079,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -931,7 +1098,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -943,7 +1117,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -955,7 +1136,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -967,7 +1155,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -979,7 +1174,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -991,7 +1193,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1005,8 +1214,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1026,8 +1241,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1045,12 +1266,23 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(valueValue))
                                     {
-                                        poco.Value = int.Parse(valueValue);
+                                        if (int.TryParse(valueValue, out var valueValueAsInt))
+                                        {
+                                            poco.Value = valueValueAsInt;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse int value '{Value}' for property 'value' on element {ElementId}", valueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralInteger at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs
index 03e6f6423..0da92e43a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class LiteralRationalReader : XmiDataReader<ILiteralRational>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public LiteralRationalReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralRationalReader>.Instance : loggerFactory.CreateLogger<LiteralRationalReader>();
@@ -277,6 +279,10 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -353,7 +363,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -377,7 +394,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -389,7 +413,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -401,7 +432,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -413,7 +451,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -425,7 +470,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -437,7 +489,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -449,7 +508,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -461,7 +527,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -473,7 +546,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,7 +565,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -497,7 +584,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -511,8 +605,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -532,8 +632,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -551,12 +657,23 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(valueValue))
                                     {
-                                        poco.Value = double.Parse(valueValue);
+                                        if (double.TryParse(valueValue, out var valueValueAsDouble))
+                                        {
+                                            poco.Value = valueValueAsDouble;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse double value '{Value}' for property 'value' on element {ElementId}", valueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralRational at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -771,6 +888,10 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -787,6 +908,10 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -847,7 +972,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -871,7 +1003,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -883,7 +1022,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -895,7 +1041,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -907,7 +1060,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -919,7 +1079,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -931,7 +1098,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -943,7 +1117,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -955,7 +1136,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -967,7 +1155,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -979,7 +1174,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -991,7 +1193,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1005,8 +1214,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1026,8 +1241,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1045,12 +1266,23 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(valueValue))
                                     {
-                                        poco.Value = double.Parse(valueValue);
+                                        if (double.TryParse(valueValue, out var valueValueAsDouble))
+                                        {
+                                            poco.Value = valueValueAsDouble;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse double value '{Value}' for property 'value' on element {ElementId}", valueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralRational at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs
index 8460c6eb6..34bf6660c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class LiteralStringReader : XmiDataReader<ILiteralString>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public LiteralStringReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<LiteralStringReader>.Instance : loggerFactory.CreateLogger<LiteralStringReader>();
@@ -277,6 +279,10 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -350,7 +360,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -374,7 +391,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -386,7 +410,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -398,7 +429,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +448,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +467,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +486,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +505,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +524,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +543,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +562,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +581,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -508,8 +602,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -529,8 +629,14 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -554,6 +660,10 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralString at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -768,6 +878,10 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -784,6 +898,10 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -841,7 +959,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -865,7 +990,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -877,7 +1009,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -889,7 +1028,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -901,7 +1047,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -913,7 +1066,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -925,7 +1085,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -937,7 +1104,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -949,7 +1123,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -961,7 +1142,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,7 +1161,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -985,7 +1180,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,8 +1201,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1020,8 +1228,14 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1045,6 +1259,10 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralString at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs
index ffb6c83e0..30d3ad83f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class MembershipExposeReader : XmiDataReader<IMembershipExpose>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MembershipExposeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MembershipExposeReader>.Instance : loggerFactory.CreateLogger<MembershipExposeReader>();
@@ -149,6 +151,10 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'importedMembership' on element {ElementId}", importedMembershipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -203,6 +209,10 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -223,6 +233,10 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -239,6 +253,10 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -249,6 +267,10 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -323,8 +345,14 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var importedMembershipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var importedMembershipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'importedMembership' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -342,7 +370,14 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -354,7 +389,14 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -366,7 +408,14 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImportAllValue))
                                     {
-                                        poco.IsImportAll = bool.Parse(isImportAllValue);
+                                        if (bool.TryParse(isImportAllValue, out var isImportAllValueAsBool))
+                                        {
+                                            poco.IsImportAll = isImportAllValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImportAll' on element {ElementId}", isImportAllValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -378,7 +427,14 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isRecursiveValue))
                                     {
-                                        poco.IsRecursive = bool.Parse(isRecursiveValue);
+                                        if (bool.TryParse(isRecursiveValue, out var isRecursiveValueAsBool))
+                                        {
+                                            poco.IsRecursive = isRecursiveValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isRecursive' on element {ElementId}", isRecursiveValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -392,8 +448,14 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -413,8 +475,14 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -434,8 +502,14 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -455,8 +529,14 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -474,12 +554,23 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MembershipExpose at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -570,6 +661,10 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'importedMembership' on element {ElementId}", importedMembershipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -624,6 +719,10 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -644,6 +743,10 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -660,6 +763,10 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -670,6 +777,10 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -744,8 +855,14 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var importedMembershipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var importedMembershipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'importedMembership' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -763,7 +880,14 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -775,7 +899,14 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -787,7 +918,14 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImportAllValue))
                                     {
-                                        poco.IsImportAll = bool.Parse(isImportAllValue);
+                                        if (bool.TryParse(isImportAllValue, out var isImportAllValueAsBool))
+                                        {
+                                            poco.IsImportAll = isImportAllValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImportAll' on element {ElementId}", isImportAllValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -799,7 +937,14 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isRecursiveValue))
                                     {
-                                        poco.IsRecursive = bool.Parse(isRecursiveValue);
+                                        if (bool.TryParse(isRecursiveValue, out var isRecursiveValueAsBool))
+                                        {
+                                            poco.IsRecursive = isRecursiveValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isRecursive' on element {ElementId}", isRecursiveValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -813,8 +958,14 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -834,8 +985,14 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -855,8 +1012,14 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -876,8 +1039,14 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -895,12 +1064,23 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MembershipExpose at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs
index 529f16caa..24904b3c2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class MembershipImportReader : XmiDataReader<IMembershipImport>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MembershipImportReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MembershipImportReader>.Instance : loggerFactory.CreateLogger<MembershipImportReader>();
@@ -148,6 +150,10 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'importedMembership' on element {ElementId}", importedMembershipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -202,6 +208,10 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -222,6 +232,10 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -238,6 +252,10 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -248,6 +266,10 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -322,8 +344,14 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var importedMembershipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var importedMembershipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'importedMembership' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -341,7 +369,14 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -353,7 +388,14 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -365,7 +407,14 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImportAllValue))
                                     {
-                                        poco.IsImportAll = bool.Parse(isImportAllValue);
+                                        if (bool.TryParse(isImportAllValue, out var isImportAllValueAsBool))
+                                        {
+                                            poco.IsImportAll = isImportAllValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImportAll' on element {ElementId}", isImportAllValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -377,7 +426,14 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isRecursiveValue))
                                     {
-                                        poco.IsRecursive = bool.Parse(isRecursiveValue);
+                                        if (bool.TryParse(isRecursiveValue, out var isRecursiveValueAsBool))
+                                        {
+                                            poco.IsRecursive = isRecursiveValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isRecursive' on element {ElementId}", isRecursiveValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,8 +447,14 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -412,8 +474,14 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -433,8 +501,14 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -454,8 +528,14 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -473,12 +553,23 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MembershipImport at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -569,6 +660,10 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'importedMembership' on element {ElementId}", importedMembershipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -623,6 +718,10 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -643,6 +742,10 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -659,6 +762,10 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -669,6 +776,10 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -743,8 +854,14 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var importedMembershipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var importedMembershipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedMembership", importedMembershipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'importedMembership' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -762,7 +879,14 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -774,7 +898,14 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -786,7 +917,14 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImportAllValue))
                                     {
-                                        poco.IsImportAll = bool.Parse(isImportAllValue);
+                                        if (bool.TryParse(isImportAllValue, out var isImportAllValueAsBool))
+                                        {
+                                            poco.IsImportAll = isImportAllValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImportAll' on element {ElementId}", isImportAllValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -798,7 +936,14 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isRecursiveValue))
                                     {
-                                        poco.IsRecursive = bool.Parse(isRecursiveValue);
+                                        if (bool.TryParse(isRecursiveValue, out var isRecursiveValueAsBool))
+                                        {
+                                            poco.IsRecursive = isRecursiveValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isRecursive' on element {ElementId}", isRecursiveValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -812,8 +957,14 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -833,8 +984,14 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -854,8 +1011,14 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -875,8 +1038,14 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -894,12 +1063,23 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MembershipImport at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs
index 82b386bf2..9890089dd 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class MembershipReader : XmiDataReader<IMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MembershipReader>.Instance : loggerFactory.CreateLogger<MembershipReader>();
@@ -168,6 +170,10 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'memberElement' on element {ElementId}", memberElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var memberNameXmlAttribute = xmiReader.GetAttribute("memberName");
@@ -196,6 +202,10 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -216,6 +226,10 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -232,6 +246,10 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -242,6 +260,10 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -314,7 +336,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -326,7 +355,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -340,8 +376,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var memberElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var memberElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'memberElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -385,8 +427,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -406,8 +454,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -427,8 +481,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -448,8 +508,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -467,12 +533,23 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Membership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -583,6 +660,10 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'memberElement' on element {ElementId}", memberElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var memberNameXmlAttribute = xmiReader.GetAttribute("memberName");
@@ -611,6 +692,10 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -631,6 +716,10 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -647,6 +736,10 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -657,6 +750,10 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -729,7 +826,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -741,7 +845,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -755,8 +866,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var memberElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var memberElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'memberElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -800,8 +917,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -821,8 +944,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -842,8 +971,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -863,8 +998,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -882,12 +1023,23 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Membership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs
index e48bf552a..0031067a3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class MergeNodeReader : XmiDataReader<IMergeNode>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MergeNodeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MergeNodeReader>.Instance : loggerFactory.CreateLogger<MergeNodeReader>();
@@ -310,6 +312,10 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -326,6 +332,10 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -386,7 +396,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +427,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +446,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +465,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +484,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +503,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +522,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +541,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +560,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -506,7 +579,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -518,7 +598,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -530,7 +617,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -542,7 +636,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -556,8 +657,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -577,8 +684,14 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,12 +709,23 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MergeNode at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -826,6 +950,10 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -842,6 +970,10 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -902,7 +1034,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -926,7 +1065,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -938,7 +1084,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -950,7 +1103,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -962,7 +1122,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -974,7 +1141,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -986,7 +1160,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -998,7 +1179,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1010,7 +1198,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1022,7 +1217,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1034,7 +1236,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1046,7 +1255,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1058,7 +1274,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1072,8 +1295,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1093,8 +1322,14 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1112,12 +1347,23 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MergeNode at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs
index d1d7721b7..19a18210a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Metadata;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class MetaclassReader : XmiDataReader<IMetaclass>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MetaclassReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MetaclassReader>.Instance : loggerFactory.CreateLogger<MetaclassReader>();
@@ -186,6 +188,10 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -202,6 +208,10 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -264,7 +274,14 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -276,7 +293,14 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -288,7 +312,14 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -302,8 +333,14 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -323,8 +360,14 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -336,6 +379,10 @@ public override IMetaclass Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Metaclass at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -460,6 +507,10 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -476,6 +527,10 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -538,7 +593,14 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -550,7 +612,14 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -562,7 +631,14 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -576,8 +652,14 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,8 +679,14 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -610,6 +698,10 @@ public override async Task<IMetaclass> ReadAsync(XmlReader xmiReader, Uri curren
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Metaclass at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs
index 5c4de7157..ec2e5d05b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class MetadataAccessExpressionReader : XmiDataReader<IMetadataAccessExpre
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MetadataAccessExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MetadataAccessExpressionReader>.Instance : loggerFactory.CreateLogger<MetadataAccessExpressionReader>();
@@ -277,6 +279,10 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -343,7 +353,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,7 +384,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -379,7 +403,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,7 +422,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -403,7 +441,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -415,7 +460,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -427,7 +479,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -439,7 +498,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -451,7 +517,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -463,7 +536,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -475,7 +555,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -487,7 +574,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,8 +595,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -522,8 +622,14 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -535,6 +641,10 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MetadataAccessExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -749,6 +859,10 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -765,6 +879,10 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -815,7 +933,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -839,7 +964,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -851,7 +983,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -863,7 +1002,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -875,7 +1021,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -887,7 +1040,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -899,7 +1059,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -911,7 +1078,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -923,7 +1097,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -935,7 +1116,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -947,7 +1135,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -959,7 +1154,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,8 +1175,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -994,8 +1202,14 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1007,6 +1221,10 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MetadataAccessExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs
index 5bdafe905..d73e3ad71 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class MetadataDefinitionReader : XmiDataReader<IMetadataDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MetadataDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MetadataDefinitionReader>.Instance : loggerFactory.CreateLogger<MetadataDefinitionReader>();
@@ -227,6 +229,10 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -243,6 +249,10 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -305,7 +315,14 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +334,14 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +353,14 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -341,7 +372,14 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -353,7 +391,14 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,8 +412,14 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -388,8 +439,14 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,6 +458,10 @@ public override IMetadataDefinition Read(XmlReader xmiReader, Uri currentLocatio
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MetadataDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -545,6 +606,10 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -561,6 +626,10 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -623,7 +692,14 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -635,7 +711,14 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -647,7 +730,14 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -659,7 +749,14 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -671,7 +768,14 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,8 +789,14 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -706,8 +816,14 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -719,6 +835,10 @@ public override async Task<IMetadataDefinition> ReadAsync(XmlReader xmiReader, U
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MetadataDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs
index 7a69a6b07..f8ca84489 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Metadata;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class MetadataFeatureReader : XmiDataReader<IMetadataFeature>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MetadataFeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MetadataFeatureReader>.Instance : loggerFactory.CreateLogger<MetadataFeatureReader>();
@@ -275,6 +277,10 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -291,6 +297,10 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -341,7 +351,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -365,7 +382,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -377,7 +401,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -389,7 +420,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -401,7 +439,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -413,7 +458,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -425,7 +477,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -437,7 +496,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -449,7 +515,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -461,7 +534,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -473,7 +553,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,7 +572,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -499,8 +593,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -520,8 +620,14 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -533,6 +639,10 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MetadataFeature at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -747,6 +857,10 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -763,6 +877,10 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -813,7 +931,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -837,7 +962,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -849,7 +981,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -861,7 +1000,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -873,7 +1019,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -885,7 +1038,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -897,7 +1057,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -909,7 +1076,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -921,7 +1095,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -933,7 +1114,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -945,7 +1133,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -957,7 +1152,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -971,8 +1173,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -992,8 +1200,14 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1005,6 +1219,10 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MetadataFeature at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs
index 84bb3799f..593e76f1a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Metadata;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class MetadataUsageReader : XmiDataReader<IMetadataUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MetadataUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MetadataUsageReader>.Instance : loggerFactory.CreateLogger<MetadataUsageReader>();
@@ -311,6 +313,10 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MetadataUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MetadataUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs
index 04fd064a6..962680fed 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Multiplicities;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class MultiplicityRangeReader : XmiDataReader<IMultiplicityRange>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MultiplicityRangeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MultiplicityRangeReader>.Instance : loggerFactory.CreateLogger<MultiplicityRangeReader>();
@@ -276,6 +278,10 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -292,6 +298,10 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -342,7 +352,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -366,7 +383,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -378,7 +402,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -390,7 +421,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -402,7 +440,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -414,7 +459,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -426,7 +478,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -438,7 +497,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -450,7 +516,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -462,7 +535,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -474,7 +554,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -486,7 +573,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -500,8 +594,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -521,8 +621,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -534,6 +640,10 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MultiplicityRange at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -748,6 +858,10 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -764,6 +878,10 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -814,7 +932,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -838,7 +963,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -850,7 +982,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -862,7 +1001,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -874,7 +1020,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -886,7 +1039,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -898,7 +1058,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -910,7 +1077,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -922,7 +1096,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -934,7 +1115,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -946,7 +1134,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -958,7 +1153,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -972,8 +1174,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -993,8 +1201,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1006,6 +1220,10 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MultiplicityRange at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs
index 4e899b25f..4f8ad0aa6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs
@@ -39,6 +39,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -63,6 +64,7 @@ public class MultiplicityReader : XmiDataReader<IMultiplicity>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public MultiplicityReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<MultiplicityReader>.Instance : loggerFactory.CreateLogger<MultiplicityReader>();
@@ -274,6 +276,10 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -290,6 +296,10 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -340,7 +350,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -364,7 +381,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -376,7 +400,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -388,7 +419,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -400,7 +438,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -412,7 +457,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -424,7 +476,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -436,7 +495,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -448,7 +514,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -460,7 +533,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -472,7 +552,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -484,7 +571,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -498,8 +592,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -519,8 +619,14 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -532,6 +638,10 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Multiplicity at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -746,6 +856,10 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -762,6 +876,10 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -812,7 +930,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -836,7 +961,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -848,7 +980,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -860,7 +999,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -872,7 +1018,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -884,7 +1037,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -896,7 +1056,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -908,7 +1075,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -920,7 +1094,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -932,7 +1113,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -944,7 +1132,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -956,7 +1151,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -970,8 +1172,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -991,8 +1199,14 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1004,6 +1218,10 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Multiplicity at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs
index feabf7ff6..018e53e4f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class NamespaceExposeReader : XmiDataReader<INamespaceExpose>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public NamespaceExposeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<NamespaceExposeReader>.Instance : loggerFactory.CreateLogger<NamespaceExposeReader>();
@@ -149,6 +151,10 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'importedNamespace' on element {ElementId}", importedNamespaceXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -203,6 +209,10 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -223,6 +233,10 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -239,6 +253,10 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -249,6 +267,10 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -323,8 +345,14 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var importedNamespaceId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceId);
+                                        if (Guid.TryParse(hrefSplit[1], out var importedNamespaceId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'importedNamespace' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -342,7 +370,14 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -354,7 +389,14 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -366,7 +408,14 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImportAllValue))
                                     {
-                                        poco.IsImportAll = bool.Parse(isImportAllValue);
+                                        if (bool.TryParse(isImportAllValue, out var isImportAllValueAsBool))
+                                        {
+                                            poco.IsImportAll = isImportAllValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImportAll' on element {ElementId}", isImportAllValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -378,7 +427,14 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isRecursiveValue))
                                     {
-                                        poco.IsRecursive = bool.Parse(isRecursiveValue);
+                                        if (bool.TryParse(isRecursiveValue, out var isRecursiveValueAsBool))
+                                        {
+                                            poco.IsRecursive = isRecursiveValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isRecursive' on element {ElementId}", isRecursiveValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -392,8 +448,14 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -413,8 +475,14 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -434,8 +502,14 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -455,8 +529,14 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -474,12 +554,23 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading NamespaceExpose at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -570,6 +661,10 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'importedNamespace' on element {ElementId}", importedNamespaceXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -624,6 +719,10 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -644,6 +743,10 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -660,6 +763,10 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -670,6 +777,10 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -744,8 +855,14 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var importedNamespaceId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceId);
+                                        if (Guid.TryParse(hrefSplit[1], out var importedNamespaceId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'importedNamespace' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -763,7 +880,14 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -775,7 +899,14 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -787,7 +918,14 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImportAllValue))
                                     {
-                                        poco.IsImportAll = bool.Parse(isImportAllValue);
+                                        if (bool.TryParse(isImportAllValue, out var isImportAllValueAsBool))
+                                        {
+                                            poco.IsImportAll = isImportAllValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImportAll' on element {ElementId}", isImportAllValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -799,7 +937,14 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isRecursiveValue))
                                     {
-                                        poco.IsRecursive = bool.Parse(isRecursiveValue);
+                                        if (bool.TryParse(isRecursiveValue, out var isRecursiveValueAsBool))
+                                        {
+                                            poco.IsRecursive = isRecursiveValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isRecursive' on element {ElementId}", isRecursiveValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -813,8 +958,14 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -834,8 +985,14 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -855,8 +1012,14 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -876,8 +1039,14 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -895,12 +1064,23 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading NamespaceExpose at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs
index 353fed585..45ff42036 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class NamespaceImportReader : XmiDataReader<INamespaceImport>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public NamespaceImportReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<NamespaceImportReader>.Instance : loggerFactory.CreateLogger<NamespaceImportReader>();
@@ -148,6 +150,10 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'importedNamespace' on element {ElementId}", importedNamespaceXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -202,6 +208,10 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -222,6 +232,10 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -238,6 +252,10 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -248,6 +266,10 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -322,8 +344,14 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var importedNamespaceId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceId);
+                                        if (Guid.TryParse(hrefSplit[1], out var importedNamespaceId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'importedNamespace' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -341,7 +369,14 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -353,7 +388,14 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -365,7 +407,14 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImportAllValue))
                                     {
-                                        poco.IsImportAll = bool.Parse(isImportAllValue);
+                                        if (bool.TryParse(isImportAllValue, out var isImportAllValueAsBool))
+                                        {
+                                            poco.IsImportAll = isImportAllValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImportAll' on element {ElementId}", isImportAllValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -377,7 +426,14 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isRecursiveValue))
                                     {
-                                        poco.IsRecursive = bool.Parse(isRecursiveValue);
+                                        if (bool.TryParse(isRecursiveValue, out var isRecursiveValueAsBool))
+                                        {
+                                            poco.IsRecursive = isRecursiveValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isRecursive' on element {ElementId}", isRecursiveValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,8 +447,14 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -412,8 +474,14 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -433,8 +501,14 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -454,8 +528,14 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -473,12 +553,23 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading NamespaceImport at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -569,6 +660,10 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'importedNamespace' on element {ElementId}", importedNamespaceXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -623,6 +718,10 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -643,6 +742,10 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -659,6 +762,10 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -669,6 +776,10 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -743,8 +854,14 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var importedNamespaceId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceId);
+                                        if (Guid.TryParse(hrefSplit[1], out var importedNamespaceId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "importedNamespace", importedNamespaceId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'importedNamespace' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -762,7 +879,14 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -774,7 +898,14 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -786,7 +917,14 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImportAllValue))
                                     {
-                                        poco.IsImportAll = bool.Parse(isImportAllValue);
+                                        if (bool.TryParse(isImportAllValue, out var isImportAllValueAsBool))
+                                        {
+                                            poco.IsImportAll = isImportAllValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImportAll' on element {ElementId}", isImportAllValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -798,7 +936,14 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isRecursiveValue))
                                     {
-                                        poco.IsRecursive = bool.Parse(isRecursiveValue);
+                                        if (bool.TryParse(isRecursiveValue, out var isRecursiveValueAsBool))
+                                        {
+                                            poco.IsRecursive = isRecursiveValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isRecursive' on element {ElementId}", isRecursiveValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -812,8 +957,14 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -833,8 +984,14 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -854,8 +1011,14 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -875,8 +1038,14 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -894,12 +1063,23 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading NamespaceImport at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs
index c7d8b3683..f728eb5e2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs
@@ -36,6 +36,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -60,6 +61,7 @@ public class NamespaceReader : XmiDataReader<INamespace>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public NamespaceReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<NamespaceReader>.Instance : loggerFactory.CreateLogger<NamespaceReader>();
@@ -161,6 +163,10 @@ public override INamespace Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -177,6 +183,10 @@ public override INamespace Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -239,7 +249,14 @@ public override INamespace Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -253,8 +270,14 @@ public override INamespace Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -274,8 +297,14 @@ public override INamespace Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -287,6 +316,10 @@ public override INamespace Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Namespace at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -391,6 +424,10 @@ public override async Task<INamespace> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -407,6 +444,10 @@ public override async Task<INamespace> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -469,7 +510,14 @@ public override async Task<INamespace> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,8 +531,14 @@ public override async Task<INamespace> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -504,8 +558,14 @@ public override async Task<INamespace> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -517,6 +577,10 @@ public override async Task<INamespace> ReadAsync(XmlReader xmiReader, Uri curren
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Namespace at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs
index 808b70160..3d831ba69 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class NullExpressionReader : XmiDataReader<INullExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public NullExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<NullExpressionReader>.Instance : loggerFactory.CreateLogger<NullExpressionReader>();
@@ -277,6 +279,10 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -293,6 +299,10 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -343,7 +353,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,7 +384,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -379,7 +403,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,7 +422,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -403,7 +441,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -415,7 +460,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -427,7 +479,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -439,7 +498,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -451,7 +517,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -463,7 +536,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -475,7 +555,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -487,7 +574,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,8 +595,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -522,8 +622,14 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -535,6 +641,10 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading NullExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -749,6 +859,10 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -765,6 +879,10 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -815,7 +933,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -839,7 +964,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -851,7 +983,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -863,7 +1002,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -875,7 +1021,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -887,7 +1040,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -899,7 +1059,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -911,7 +1078,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -923,7 +1097,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -935,7 +1116,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -947,7 +1135,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -959,7 +1154,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,8 +1175,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -994,8 +1202,14 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1007,6 +1221,10 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading NullExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs
index f3513bdff..c2c73c217 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class ObjectiveMembershipReader : XmiDataReader<IObjectiveMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ObjectiveMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ObjectiveMembershipReader>.Instance : loggerFactory.CreateLogger<ObjectiveMembershipReader>();
@@ -176,6 +178,10 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -196,6 +202,10 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -212,6 +222,10 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -222,6 +236,10 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -294,7 +312,14 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -306,7 +331,14 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -320,8 +352,14 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -341,8 +379,14 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -362,8 +406,14 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -383,8 +433,14 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,12 +458,23 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ObjectiveMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -522,6 +589,10 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -542,6 +613,10 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -558,6 +633,10 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -568,6 +647,10 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -640,7 +723,14 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -652,7 +742,14 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -666,8 +763,14 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -687,8 +790,14 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -708,8 +817,14 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -729,8 +844,14 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -748,12 +869,23 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ObjectiveMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs
index 75af87f1c..8370b435a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class OccurrenceDefinitionReader : XmiDataReader<IOccurrenceDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public OccurrenceDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<OccurrenceDefinitionReader>.Instance : loggerFactory.CreateLogger<OccurrenceDefinitionReader>();
@@ -227,6 +229,10 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -243,6 +249,10 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -305,7 +315,14 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +334,14 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +353,14 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -341,7 +372,14 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -353,7 +391,14 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,8 +412,14 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -388,8 +439,14 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,6 +458,10 @@ public override IOccurrenceDefinition Read(XmlReader xmiReader, Uri currentLocat
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading OccurrenceDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -545,6 +606,10 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -561,6 +626,10 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -623,7 +692,14 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -635,7 +711,14 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -647,7 +730,14 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -659,7 +749,14 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -671,7 +768,14 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,8 +789,14 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -706,8 +816,14 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -719,6 +835,10 @@ public override async Task<IOccurrenceDefinition> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading OccurrenceDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs
index 88b5dffb7..51cbef9ca 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Occurrences;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -88,6 +89,7 @@ public class OccurrenceUsageReader : XmiDataReader<IOccurrenceUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public OccurrenceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<OccurrenceUsageReader>.Instance : loggerFactory.CreateLogger<OccurrenceUsageReader>();
@@ -309,6 +311,10 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -325,6 +331,10 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -385,7 +395,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -409,7 +426,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -421,7 +445,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -433,7 +464,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -445,7 +483,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -457,7 +502,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -469,7 +521,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -481,7 +540,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -493,7 +559,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -505,7 +578,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -517,7 +597,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -529,7 +616,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -541,7 +635,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -555,8 +656,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -576,8 +683,14 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -595,12 +708,23 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading OccurrenceUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -825,6 +949,10 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -841,6 +969,10 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -901,7 +1033,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -925,7 +1064,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -937,7 +1083,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -949,7 +1102,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -961,7 +1121,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,7 +1140,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -985,7 +1159,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -997,7 +1178,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1009,7 +1197,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1021,7 +1216,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1033,7 +1235,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1045,7 +1254,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1057,7 +1273,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1071,8 +1294,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1092,8 +1321,14 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1111,12 +1346,23 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading OccurrenceUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs
index 416593639..09c5f8b66 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class OperatorExpressionReader : XmiDataReader<IOperatorExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public OperatorExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<OperatorExpressionReader>.Instance : loggerFactory.CreateLogger<OperatorExpressionReader>();
@@ -284,6 +286,10 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -300,6 +306,10 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -350,7 +360,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -374,7 +391,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -386,7 +410,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -398,7 +429,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +448,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +467,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +486,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +505,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +524,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +543,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +562,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +581,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -520,8 +614,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -541,8 +641,14 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -554,6 +660,10 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading OperatorExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -775,6 +885,10 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -791,6 +905,10 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -841,7 +959,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -865,7 +990,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -877,7 +1009,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -889,7 +1028,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -901,7 +1047,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -913,7 +1066,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -925,7 +1085,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -937,7 +1104,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -949,7 +1123,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -961,7 +1142,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,7 +1161,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -985,7 +1180,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,8 +1213,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1032,8 +1240,14 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1045,6 +1259,10 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading OperatorExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs
index cc7e22998..75b7aee0d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class OwningMembershipReader : XmiDataReader<IOwningMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public OwningMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<OwningMembershipReader>.Instance : loggerFactory.CreateLogger<OwningMembershipReader>();
@@ -172,6 +174,10 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -192,6 +198,10 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -208,6 +218,10 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -218,6 +232,10 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -290,7 +308,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -302,7 +327,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -316,8 +348,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -337,8 +375,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -358,8 +402,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -379,8 +429,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -398,12 +454,23 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading OwningMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -518,6 +585,10 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -538,6 +609,10 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -554,6 +629,10 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -564,6 +643,10 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -636,7 +719,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -648,7 +738,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -662,8 +759,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -683,8 +786,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -704,8 +813,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -725,8 +840,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -744,12 +865,23 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading OwningMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs
index 76defa21d..2f95dbb1e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Packages;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class PackageReader : XmiDataReader<IPackage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public PackageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PackageReader>.Instance : loggerFactory.CreateLogger<PackageReader>();
@@ -163,6 +165,10 @@ public override IPackage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -179,6 +185,10 @@ public override IPackage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -241,7 +251,14 @@ public override IPackage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -255,8 +272,14 @@ public override IPackage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -276,8 +299,14 @@ public override IPackage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -289,6 +318,10 @@ public override IPackage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Package at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -393,6 +426,10 @@ public override async Task<IPackage> ReadAsync(XmlReader xmiReader, Uri currentL
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -409,6 +446,10 @@ public override async Task<IPackage> ReadAsync(XmlReader xmiReader, Uri currentL
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -471,7 +512,14 @@ public override async Task<IPackage> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,8 +533,14 @@ public override async Task<IPackage> ReadAsync(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -506,8 +560,14 @@ public override async Task<IPackage> ReadAsync(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -519,6 +579,10 @@ public override async Task<IPackage> ReadAsync(XmlReader xmiReader, Uri currentL
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Package at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs
index 713b3338a..b67c4b926 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class ParameterMembershipReader : XmiDataReader<IParameterMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ParameterMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ParameterMembershipReader>.Instance : loggerFactory.CreateLogger<ParameterMembershipReader>();
@@ -175,6 +177,10 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -195,6 +201,10 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -211,6 +221,10 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -221,6 +235,10 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -293,7 +311,14 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -305,7 +330,14 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -319,8 +351,14 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -340,8 +378,14 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -361,8 +405,14 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -382,8 +432,14 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,12 +457,23 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ParameterMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -521,6 +588,10 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -541,6 +612,10 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -557,6 +632,10 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -567,6 +646,10 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -639,7 +722,14 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -651,7 +741,14 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -665,8 +762,14 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -686,8 +789,14 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,8 +816,14 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -728,8 +843,14 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -747,12 +868,23 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ParameterMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs
index be58de6e4..af550c2fd 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs
@@ -61,6 +61,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -85,6 +86,7 @@ public class PartDefinitionReader : XmiDataReader<IPartDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public PartDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PartDefinitionReader>.Instance : loggerFactory.CreateLogger<PartDefinitionReader>();
@@ -226,6 +228,10 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -242,6 +248,10 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -304,7 +314,14 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -316,7 +333,14 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -328,7 +352,14 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -340,7 +371,14 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -352,7 +390,14 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -366,8 +411,14 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -387,8 +438,14 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,6 +457,10 @@ public override IPartDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PartDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -544,6 +605,10 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -560,6 +625,10 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -622,7 +691,14 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -634,7 +710,14 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -646,7 +729,14 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -658,7 +748,14 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -670,7 +767,14 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -684,8 +788,14 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -705,8 +815,14 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -718,6 +834,10 @@ public override async Task<IPartDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PartDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs
index 060f30956..da340b901 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class PartUsageReader : XmiDataReader<IPartUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public PartUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PartUsageReader>.Instance : loggerFactory.CreateLogger<PartUsageReader>();
@@ -310,6 +312,10 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -326,6 +332,10 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -386,7 +396,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +427,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +446,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +465,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +484,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +503,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +522,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +541,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +560,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -506,7 +579,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -518,7 +598,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -530,7 +617,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -542,7 +636,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -556,8 +657,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -577,8 +684,14 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,12 +709,23 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PartUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -826,6 +950,10 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -842,6 +970,10 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -902,7 +1034,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -926,7 +1065,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -938,7 +1084,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -950,7 +1103,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -962,7 +1122,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -974,7 +1141,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -986,7 +1160,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -998,7 +1179,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1010,7 +1198,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1022,7 +1217,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1034,7 +1236,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1046,7 +1255,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1058,7 +1274,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1072,8 +1295,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1093,8 +1322,14 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1112,12 +1347,23 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PartUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs
index d5f6bb908..418e3359e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class PayloadFeatureReader : XmiDataReader<IPayloadFeature>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public PayloadFeatureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PayloadFeatureReader>.Instance : loggerFactory.CreateLogger<PayloadFeatureReader>();
@@ -275,6 +277,10 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -291,6 +297,10 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -341,7 +351,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -365,7 +382,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -377,7 +401,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -389,7 +420,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -401,7 +439,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -413,7 +458,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -425,7 +477,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -437,7 +496,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -449,7 +515,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -461,7 +534,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -473,7 +553,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,7 +572,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -499,8 +593,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -520,8 +620,14 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -533,6 +639,10 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PayloadFeature at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -747,6 +857,10 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -763,6 +877,10 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -813,7 +931,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -837,7 +962,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -849,7 +981,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -861,7 +1000,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -873,7 +1019,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -885,7 +1038,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -897,7 +1057,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -909,7 +1076,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -921,7 +1095,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -933,7 +1114,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -945,7 +1133,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -957,7 +1152,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -971,8 +1173,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -992,8 +1200,14 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1005,6 +1219,10 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PayloadFeature at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs
index 5d470a655..d335ba175 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class PerformActionUsageReader : XmiDataReader<IPerformActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public PerformActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PerformActionUsageReader>.Instance : loggerFactory.CreateLogger<PerformActionUsageReader>();
@@ -310,6 +312,10 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -326,6 +332,10 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -386,7 +396,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +427,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +446,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +465,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +484,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +503,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +522,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +541,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +560,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -506,7 +579,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -518,7 +598,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -530,7 +617,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -542,7 +636,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -556,8 +657,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -577,8 +684,14 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,12 +709,23 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PerformActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -826,6 +950,10 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -842,6 +970,10 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -902,7 +1034,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -926,7 +1065,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -938,7 +1084,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -950,7 +1103,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -962,7 +1122,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -974,7 +1141,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -986,7 +1160,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -998,7 +1179,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1010,7 +1198,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1022,7 +1217,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1034,7 +1236,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1046,7 +1255,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1058,7 +1274,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1072,8 +1295,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1093,8 +1322,14 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1112,12 +1347,23 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PerformActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs
index a244c3b3d..daf5f56be 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class PortConjugationReader : XmiDataReader<IPortConjugation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public PortConjugationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PortConjugationReader>.Instance : loggerFactory.CreateLogger<PortConjugationReader>();
@@ -128,6 +130,10 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'conjugatedType' on element {ElementId}", conjugatedTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -179,6 +185,10 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalPortDefinition", originalPortDefinitionXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'originalPortDefinition' on element {ElementId}", originalPortDefinitionXmlAttribute, poco.Id);
+                    }
                 }
 
                 var ownedRelatedElementXmlAttribute = xmiReader.GetAttribute("ownedRelatedElement");
@@ -193,6 +203,10 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -213,6 +227,10 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -229,6 +247,10 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -239,6 +261,10 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -267,8 +293,14 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var conjugatedTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var conjugatedTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'conjugatedType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -322,7 +354,14 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -334,7 +373,14 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -348,8 +394,14 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var originalPortDefinitionId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalPortDefinition", originalPortDefinitionId);
+                                        if (Guid.TryParse(hrefSplit[1], out var originalPortDefinitionId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalPortDefinition", originalPortDefinitionId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'originalPortDefinition' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -369,8 +421,14 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -390,8 +448,14 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -411,8 +475,14 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -432,8 +502,14 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -445,6 +521,10 @@ public override IPortConjugation Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PortConjugation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -514,6 +594,10 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'conjugatedType' on element {ElementId}", conjugatedTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var declaredNameXmlAttribute = xmiReader.GetAttribute("declaredName");
@@ -565,6 +649,10 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalPortDefinition", originalPortDefinitionXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'originalPortDefinition' on element {ElementId}", originalPortDefinitionXmlAttribute, poco.Id);
+                    }
                 }
 
                 var ownedRelatedElementXmlAttribute = xmiReader.GetAttribute("ownedRelatedElement");
@@ -579,6 +667,10 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -599,6 +691,10 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -615,6 +711,10 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -625,6 +725,10 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -653,8 +757,14 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var conjugatedTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var conjugatedTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "conjugatedType", conjugatedTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'conjugatedType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -708,7 +818,14 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -720,7 +837,14 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -734,8 +858,14 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var originalPortDefinitionId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalPortDefinition", originalPortDefinitionId);
+                                        if (Guid.TryParse(hrefSplit[1], out var originalPortDefinitionId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "originalPortDefinition", originalPortDefinitionId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'originalPortDefinition' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -755,8 +885,14 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -776,8 +912,14 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -797,8 +939,14 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -818,8 +966,14 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -831,6 +985,10 @@ public override async Task<IPortConjugation> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PortConjugation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs
index 8d13820b8..52607da64 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class PortDefinitionReader : XmiDataReader<IPortDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public PortDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PortDefinitionReader>.Instance : loggerFactory.CreateLogger<PortDefinitionReader>();
@@ -227,6 +229,10 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -243,6 +249,10 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -305,7 +315,14 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +334,14 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +353,14 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -341,7 +372,14 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -353,7 +391,14 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,8 +412,14 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -388,8 +439,14 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,6 +458,10 @@ public override IPortDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PortDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -545,6 +606,10 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -561,6 +626,10 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -623,7 +692,14 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -635,7 +711,14 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -647,7 +730,14 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -659,7 +749,14 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -671,7 +768,14 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,8 +789,14 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -706,8 +816,14 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -719,6 +835,10 @@ public override async Task<IPortDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PortDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs
index b5f047cd3..8d87c8a9a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Ports;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -88,6 +89,7 @@ public class PortUsageReader : XmiDataReader<IPortUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public PortUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PortUsageReader>.Instance : loggerFactory.CreateLogger<PortUsageReader>();
@@ -309,6 +311,10 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -325,6 +331,10 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -385,7 +395,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -409,7 +426,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -421,7 +445,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -433,7 +464,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -445,7 +483,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -457,7 +502,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -469,7 +521,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -481,7 +540,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -493,7 +559,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -505,7 +578,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -517,7 +597,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -529,7 +616,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -541,7 +635,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -555,8 +656,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -576,8 +683,14 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -595,12 +708,23 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PortUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -825,6 +949,10 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -841,6 +969,10 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -901,7 +1033,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -925,7 +1064,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -937,7 +1083,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -949,7 +1102,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -961,7 +1121,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,7 +1140,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -985,7 +1159,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -997,7 +1178,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1009,7 +1197,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1021,7 +1216,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1033,7 +1235,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1045,7 +1254,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1057,7 +1273,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1071,8 +1294,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1092,8 +1321,14 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1111,12 +1346,23 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading PortUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs
index 2fa1214bc..ae20c155f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class PredicateReader : XmiDataReader<IPredicate>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public PredicateReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<PredicateReader>.Instance : loggerFactory.CreateLogger<PredicateReader>();
@@ -186,6 +188,10 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -202,6 +208,10 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -264,7 +274,14 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -276,7 +293,14 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -288,7 +312,14 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -302,8 +333,14 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -323,8 +360,14 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -336,6 +379,10 @@ public override IPredicate Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Predicate at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -460,6 +507,10 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -476,6 +527,10 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -538,7 +593,14 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -550,7 +612,14 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -562,7 +631,14 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -576,8 +652,14 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,8 +679,14 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -610,6 +698,10 @@ public override async Task<IPredicate> ReadAsync(XmlReader xmiReader, Uri curren
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Predicate at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs
index 0e3ec10f4..2ed78277b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class RedefinitionReader : XmiDataReader<IRedefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public RedefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RedefinitionReader>.Instance : loggerFactory.CreateLogger<RedefinitionReader>();
@@ -173,6 +175,10 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -193,6 +199,10 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -209,6 +219,10 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -219,6 +233,10 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var redefinedFeatureXmlAttribute = xmiReader.GetAttribute("redefinedFeature");
@@ -229,6 +247,10 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefinedFeature", redefinedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'redefinedFeature' on element {ElementId}", redefinedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 var redefiningFeatureXmlAttribute = xmiReader.GetAttribute("redefiningFeature");
@@ -239,6 +261,10 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefiningFeature", redefiningFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'redefiningFeature' on element {ElementId}", redefiningFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -301,7 +327,14 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -313,7 +346,14 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -327,8 +367,14 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -348,8 +394,14 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -369,8 +421,14 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -390,8 +448,14 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -411,8 +475,14 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var redefinedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefinedFeature", redefinedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var redefinedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefinedFeature", redefinedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'redefinedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -432,8 +502,14 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var redefiningFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefiningFeature", redefiningFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var redefiningFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefiningFeature", redefiningFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'redefiningFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -445,6 +521,10 @@ public override IRedefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Redefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -559,6 +639,10 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -579,6 +663,10 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -595,6 +683,10 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -605,6 +697,10 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var redefinedFeatureXmlAttribute = xmiReader.GetAttribute("redefinedFeature");
@@ -615,6 +711,10 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefinedFeature", redefinedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'redefinedFeature' on element {ElementId}", redefinedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 var redefiningFeatureXmlAttribute = xmiReader.GetAttribute("redefiningFeature");
@@ -625,6 +725,10 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefiningFeature", redefiningFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'redefiningFeature' on element {ElementId}", redefiningFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -687,7 +791,14 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -699,7 +810,14 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -713,8 +831,14 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -734,8 +858,14 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -755,8 +885,14 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -776,8 +912,14 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -797,8 +939,14 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var redefinedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefinedFeature", redefinedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var redefinedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefinedFeature", redefinedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'redefinedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -818,8 +966,14 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var redefiningFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefiningFeature", redefiningFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var redefiningFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "redefiningFeature", redefiningFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'redefiningFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -831,6 +985,10 @@ public override async Task<IRedefinition> ReadAsync(XmlReader xmiReader, Uri cur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Redefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs
index 2485b6cdc..dedcadad6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class ReferenceSubsettingReader : XmiDataReader<IReferenceSubsetting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ReferenceSubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ReferenceSubsettingReader>.Instance : loggerFactory.CreateLogger<ReferenceSubsettingReader>();
@@ -173,6 +175,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -193,6 +199,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -209,6 +219,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -219,6 +233,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var referencedFeatureXmlAttribute = xmiReader.GetAttribute("referencedFeature");
@@ -229,6 +247,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'referencedFeature' on element {ElementId}", referencedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -291,7 +313,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -303,7 +332,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,8 +353,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -338,8 +380,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -359,8 +407,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -380,8 +434,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,8 +461,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var referencedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var referencedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'referencedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -414,6 +480,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ReferenceSubsetting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -528,6 +598,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -548,6 +622,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -564,6 +642,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -574,6 +656,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var referencedFeatureXmlAttribute = xmiReader.GetAttribute("referencedFeature");
@@ -584,6 +670,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'referencedFeature' on element {ElementId}", referencedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -646,7 +736,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -658,7 +755,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -672,8 +776,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -693,8 +803,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -714,8 +830,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -735,8 +857,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -756,8 +884,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var referencedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var referencedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'referencedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -769,6 +903,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ReferenceSubsetting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs
index 942dd75d2..2bcdc5b25 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class ReferenceUsageReader : XmiDataReader<IReferenceUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ReferenceUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ReferenceUsageReader>.Instance : loggerFactory.CreateLogger<ReferenceUsageReader>();
@@ -297,6 +299,10 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -313,6 +319,10 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -363,7 +373,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -387,7 +404,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -399,7 +423,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +442,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +461,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +480,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +499,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +518,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +537,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +556,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +575,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +594,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -521,8 +615,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -542,8 +642,14 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -555,6 +661,10 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ReferenceUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -769,6 +879,10 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -785,6 +899,10 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -835,7 +953,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -859,7 +984,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -871,7 +1003,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -883,7 +1022,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -895,7 +1041,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -907,7 +1060,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -919,7 +1079,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -931,7 +1098,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -943,7 +1117,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -955,7 +1136,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -967,7 +1155,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -979,7 +1174,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -993,8 +1195,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1014,8 +1222,14 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1027,6 +1241,10 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ReferenceUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs
index c13d82102..dd11cb033 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs
@@ -61,6 +61,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -85,6 +86,7 @@ public class RenderingDefinitionReader : XmiDataReader<IRenderingDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public RenderingDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RenderingDefinitionReader>.Instance : loggerFactory.CreateLogger<RenderingDefinitionReader>();
@@ -226,6 +228,10 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -242,6 +248,10 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -304,7 +314,14 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -316,7 +333,14 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -328,7 +352,14 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -340,7 +371,14 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -352,7 +390,14 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -366,8 +411,14 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -387,8 +438,14 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,6 +457,10 @@ public override IRenderingDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RenderingDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -544,6 +605,10 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -560,6 +625,10 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -622,7 +691,14 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -634,7 +710,14 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -646,7 +729,14 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -658,7 +748,14 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -670,7 +767,14 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -684,8 +788,14 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -705,8 +815,14 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -718,6 +834,10 @@ public override async Task<IRenderingDefinition> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RenderingDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs
index c2b8babf4..3fb40ed1c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class RenderingUsageReader : XmiDataReader<IRenderingUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public RenderingUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RenderingUsageReader>.Instance : loggerFactory.CreateLogger<RenderingUsageReader>();
@@ -310,6 +312,10 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -326,6 +332,10 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -386,7 +396,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +427,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +446,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +465,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +484,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +503,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +522,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +541,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +560,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -506,7 +579,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -518,7 +598,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -530,7 +617,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -542,7 +636,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -556,8 +657,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -577,8 +684,14 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,12 +709,23 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RenderingUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -826,6 +950,10 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -842,6 +970,10 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -902,7 +1034,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -926,7 +1065,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -938,7 +1084,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -950,7 +1103,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -962,7 +1122,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -974,7 +1141,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -986,7 +1160,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -998,7 +1179,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1010,7 +1198,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1022,7 +1217,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1034,7 +1236,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1046,7 +1255,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1058,7 +1274,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1072,8 +1295,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1093,8 +1322,14 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1112,12 +1347,23 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RenderingUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs
index 35b41e78e..a39cbef2c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Constraints;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class RequirementConstraintMembershipReader : XmiDataReader<IRequirementC
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public RequirementConstraintMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RequirementConstraintMembershipReader>.Instance : loggerFactory.CreateLogger<RequirementConstraintMembershipReader>();
@@ -187,6 +189,10 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -207,6 +213,10 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -223,6 +233,10 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -233,6 +247,10 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -305,7 +323,14 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +342,14 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +361,14 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (RequirementConstraintKind)Enum.Parse(typeof(RequirementConstraintKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -343,8 +382,14 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -364,8 +409,14 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -385,8 +436,14 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -406,8 +463,14 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -425,12 +488,23 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RequirementConstraintMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -555,6 +629,10 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -575,6 +653,10 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -591,6 +673,10 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -601,6 +687,10 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -673,7 +763,14 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,7 +782,14 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -697,7 +801,14 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (RequirementConstraintKind)Enum.Parse(typeof(RequirementConstraintKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -711,8 +822,14 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -732,8 +849,14 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -753,8 +876,14 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -774,8 +903,14 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -793,12 +928,23 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RequirementConstraintMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs
index 49a49c969..0ea9e4747 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class RequirementDefinitionReader : XmiDataReader<IRequirementDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public RequirementDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RequirementDefinitionReader>.Instance : loggerFactory.CreateLogger<RequirementDefinitionReader>();
@@ -221,6 +223,10 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -237,6 +243,10 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var reqIdXmlAttribute = xmiReader.GetAttribute("reqId");
@@ -294,7 +304,14 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -306,7 +323,14 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +342,14 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +361,14 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -342,7 +380,14 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -356,8 +401,14 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -377,8 +428,14 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,6 +459,10 @@ public override IRequirementDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RequirementDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -539,6 +600,10 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -555,6 +620,10 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var reqIdXmlAttribute = xmiReader.GetAttribute("reqId");
@@ -612,7 +681,14 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -624,7 +700,14 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -636,7 +719,14 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -648,7 +738,14 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -660,7 +757,14 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -674,8 +778,14 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -695,8 +805,14 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -720,6 +836,10 @@ public override async Task<IRequirementDefinition> ReadAsync(XmlReader xmiReader
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RequirementDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs
index c1c955215..8b33b96c9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class RequirementUsageReader : XmiDataReader<IRequirementUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public RequirementUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RequirementUsageReader>.Instance : loggerFactory.CreateLogger<RequirementUsageReader>();
@@ -304,6 +306,10 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -320,6 +326,10 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -375,7 +385,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -399,7 +416,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +435,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +454,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +473,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +492,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +511,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +530,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +549,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +568,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +587,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +606,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +625,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -545,8 +646,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -566,8 +673,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -585,7 +698,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -603,6 +723,10 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RequirementUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -820,6 +944,10 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -836,6 +964,10 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -891,7 +1023,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -915,7 +1054,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1073,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1092,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1111,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1130,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1149,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1168,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1187,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1206,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1225,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1244,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1263,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1061,8 +1284,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1082,8 +1311,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1101,7 +1336,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1119,6 +1361,10 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RequirementUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs
index a494efa22..acd733642 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs
@@ -43,6 +43,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.Constraints;
     using SysML2.NET.Core.POCO.Systems.Requirements;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -67,6 +68,7 @@ public class RequirementVerificationMembershipReader : XmiDataReader<IRequiremen
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public RequirementVerificationMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<RequirementVerificationMembershipReader>.Instance : loggerFactory.CreateLogger<RequirementVerificationMembershipReader>();
@@ -188,6 +190,10 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -208,6 +214,10 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -224,6 +234,10 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -234,6 +248,10 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -306,7 +324,14 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +343,14 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +362,14 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (RequirementConstraintKind)Enum.Parse(typeof(RequirementConstraintKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -344,8 +383,14 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -365,8 +410,14 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -386,8 +437,14 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -407,8 +464,14 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -426,12 +489,23 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RequirementVerificationMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -556,6 +630,10 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -576,6 +654,10 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -592,6 +674,10 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -602,6 +688,10 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -674,7 +764,14 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -686,7 +783,14 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -698,7 +802,14 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (RequirementConstraintKind)Enum.Parse(typeof(RequirementConstraintKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -712,8 +823,14 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -733,8 +850,14 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -754,8 +877,14 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -775,8 +904,14 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -794,12 +929,23 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RequirementVerificationMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs
index 0f5f6b317..50251258f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class ResultExpressionMembershipReader : XmiDataReader<IResultExpressionM
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ResultExpressionMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ResultExpressionMembershipReader>.Instance : loggerFactory.CreateLogger<ResultExpressionMembershipReader>();
@@ -175,6 +177,10 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -195,6 +201,10 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -211,6 +221,10 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -221,6 +235,10 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -293,7 +311,14 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -305,7 +330,14 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -319,8 +351,14 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -340,8 +378,14 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -361,8 +405,14 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -382,8 +432,14 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,12 +457,23 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ResultExpressionMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -521,6 +588,10 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -541,6 +612,10 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -557,6 +632,10 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -567,6 +646,10 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -639,7 +722,14 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -651,7 +741,14 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -665,8 +762,14 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -686,8 +789,14 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,8 +816,14 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -728,8 +843,14 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -747,12 +868,23 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ResultExpressionMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs
index 6a9c96fe6..ef7e2b373 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class ReturnParameterMembershipReader : XmiDataReader<IReturnParameterMem
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ReturnParameterMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ReturnParameterMembershipReader>.Instance : loggerFactory.CreateLogger<ReturnParameterMembershipReader>();
@@ -176,6 +178,10 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -196,6 +202,10 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -212,6 +222,10 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -222,6 +236,10 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -294,7 +312,14 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -306,7 +331,14 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -320,8 +352,14 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -341,8 +379,14 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -362,8 +406,14 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -383,8 +433,14 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,12 +458,23 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ReturnParameterMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -522,6 +589,10 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -542,6 +613,10 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -558,6 +633,10 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -568,6 +647,10 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -640,7 +723,14 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -652,7 +742,14 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -666,8 +763,14 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -687,8 +790,14 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -708,8 +817,14 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -729,8 +844,14 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -748,12 +869,23 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ReturnParameterMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs
index 5c4937331..80b8eaae6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class SatisfyRequirementUsageReader : XmiDataReader<ISatisfyRequirementUs
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SatisfyRequirementUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SatisfyRequirementUsageReader>.Instance : loggerFactory.CreateLogger<SatisfyRequirementUsageReader>();
@@ -314,6 +316,10 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -330,6 +336,10 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -385,7 +395,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -409,7 +426,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -421,7 +445,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -433,7 +464,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -445,7 +483,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -457,7 +502,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -469,7 +521,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -481,7 +540,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -493,7 +559,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isNegatedValue))
                                     {
-                                        poco.IsNegated = bool.Parse(isNegatedValue);
+                                        if (bool.TryParse(isNegatedValue, out var isNegatedValueAsBool))
+                                        {
+                                            poco.IsNegated = isNegatedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isNegated' on element {ElementId}", isNegatedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -505,7 +578,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -517,7 +597,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -529,7 +616,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -541,7 +635,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -553,7 +654,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -567,8 +675,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -588,8 +702,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -607,7 +727,14 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -625,6 +752,10 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SatisfyRequirementUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -852,6 +983,10 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -868,6 +1003,10 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -923,7 +1062,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -947,7 +1093,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -959,7 +1112,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -971,7 +1131,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -983,7 +1150,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -995,7 +1169,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1007,7 +1188,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1019,7 +1207,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1031,7 +1226,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isNegatedValue))
                                     {
-                                        poco.IsNegated = bool.Parse(isNegatedValue);
+                                        if (bool.TryParse(isNegatedValue, out var isNegatedValueAsBool))
+                                        {
+                                            poco.IsNegated = isNegatedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isNegated' on element {ElementId}", isNegatedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1043,7 +1245,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1055,7 +1264,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1067,7 +1283,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1079,7 +1302,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1091,7 +1321,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1105,8 +1342,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1126,8 +1369,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1145,7 +1394,14 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1163,6 +1419,10 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SatisfyRequirementUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs
index 5df7f8914..4775601ae 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Expressions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class SelectExpressionReader : XmiDataReader<ISelectExpression>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SelectExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SelectExpressionReader>.Instance : loggerFactory.CreateLogger<SelectExpressionReader>();
@@ -284,6 +286,10 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -300,6 +306,10 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -350,7 +360,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -374,7 +391,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -386,7 +410,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -398,7 +429,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -410,7 +448,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -422,7 +467,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -434,7 +486,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -446,7 +505,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -458,7 +524,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -470,7 +543,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -482,7 +562,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -494,7 +581,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -520,8 +614,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -541,8 +641,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -554,6 +660,10 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SelectExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -775,6 +885,10 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -791,6 +905,10 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -841,7 +959,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -865,7 +990,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -877,7 +1009,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -889,7 +1028,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -901,7 +1047,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -913,7 +1066,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -925,7 +1085,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -937,7 +1104,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -949,7 +1123,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -961,7 +1142,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -973,7 +1161,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -985,7 +1180,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,8 +1213,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1032,8 +1240,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1045,6 +1259,10 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SelectExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs
index e612b0c4b..bfa15b85c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class SendActionUsageReader : XmiDataReader<ISendActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SendActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SendActionUsageReader>.Instance : loggerFactory.CreateLogger<SendActionUsageReader>();
@@ -311,6 +313,10 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SendActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SendActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs
index a0b16603c..ace40f6bd 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class SpecializationReader : XmiDataReader<ISpecialization>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SpecializationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SpecializationReader>.Instance : loggerFactory.CreateLogger<SpecializationReader>();
@@ -148,6 +150,10 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "general", generalXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'general' on element {ElementId}", generalXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -182,6 +188,10 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -202,6 +212,10 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -218,6 +232,10 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -228,6 +246,10 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var specificXmlAttribute = xmiReader.GetAttribute("specific");
@@ -238,6 +260,10 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "specific", specificXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'specific' on element {ElementId}", specificXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -302,8 +328,14 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var generalId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "general", generalId);
+                                        if (Guid.TryParse(hrefSplit[1], out var generalId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "general", generalId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'general' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -321,7 +353,14 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -333,7 +372,14 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -347,8 +393,14 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -368,8 +420,14 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -389,8 +447,14 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -410,8 +474,14 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -431,8 +501,14 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var specificId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "specific", specificId);
+                                        if (Guid.TryParse(hrefSplit[1], out var specificId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "specific", specificId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'specific' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -444,6 +520,10 @@ public override ISpecialization Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Specialization at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -534,6 +614,10 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "general", generalXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'general' on element {ElementId}", generalXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -568,6 +652,10 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -588,6 +676,10 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -604,6 +696,10 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -614,6 +710,10 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var specificXmlAttribute = xmiReader.GetAttribute("specific");
@@ -624,6 +724,10 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "specific", specificXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'specific' on element {ElementId}", specificXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -688,8 +792,14 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var generalId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "general", generalId);
+                                        if (Guid.TryParse(hrefSplit[1], out var generalId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "general", generalId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'general' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,7 +817,14 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -719,7 +836,14 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -733,8 +857,14 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -754,8 +884,14 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -775,8 +911,14 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -796,8 +938,14 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -817,8 +965,14 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var specificId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "specific", specificId);
+                                        if (Guid.TryParse(hrefSplit[1], out var specificId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "specific", specificId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'specific' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -830,6 +984,10 @@ public override async Task<ISpecialization> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Specialization at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs
index ce4831175..ff8d75114 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Parts;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class StakeholderMembershipReader : XmiDataReader<IStakeholderMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public StakeholderMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StakeholderMembershipReader>.Instance : loggerFactory.CreateLogger<StakeholderMembershipReader>();
@@ -177,6 +179,10 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -197,6 +203,10 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -213,6 +223,10 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -223,6 +237,10 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -295,7 +313,14 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -307,7 +332,14 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -321,8 +353,14 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -342,8 +380,14 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -363,8 +407,14 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -384,8 +434,14 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -403,12 +459,23 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading StakeholderMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -523,6 +590,10 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -543,6 +614,10 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -559,6 +634,10 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -569,6 +648,10 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -641,7 +724,14 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -653,7 +743,14 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -667,8 +764,14 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -688,8 +791,14 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -709,8 +818,14 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -730,8 +845,14 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -749,12 +870,23 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading StakeholderMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs
index 8e280f8a9..5f95c81f3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class StateDefinitionReader : XmiDataReader<IStateDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public StateDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StateDefinitionReader>.Instance : loggerFactory.CreateLogger<StateDefinitionReader>();
@@ -237,6 +239,10 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -253,6 +259,10 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -315,7 +325,14 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -327,7 +344,14 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -339,7 +363,14 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -351,7 +382,14 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isParallelValue))
                                     {
-                                        poco.IsParallel = bool.Parse(isParallelValue);
+                                        if (bool.TryParse(isParallelValue, out var isParallelValueAsBool))
+                                        {
+                                            poco.IsParallel = isParallelValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isParallel' on element {ElementId}", isParallelValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -363,7 +401,14 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -375,7 +420,14 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -389,8 +441,14 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -410,8 +468,14 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -423,6 +487,10 @@ public override IStateDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading StateDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -577,6 +645,10 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -593,6 +665,10 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -655,7 +731,14 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -667,7 +750,14 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -679,7 +769,14 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -691,7 +788,14 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isParallelValue))
                                     {
-                                        poco.IsParallel = bool.Parse(isParallelValue);
+                                        if (bool.TryParse(isParallelValue, out var isParallelValueAsBool))
+                                        {
+                                            poco.IsParallel = isParallelValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isParallel' on element {ElementId}", isParallelValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -703,7 +807,14 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -715,7 +826,14 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -729,8 +847,14 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -750,8 +874,14 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -763,6 +893,10 @@ public override async Task<IStateDefinition> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading StateDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs
index 4f44ca63d..2431ba0e8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Actions;
     using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class StateSubactionMembershipReader : XmiDataReader<IStateSubactionMembe
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public StateSubactionMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StateSubactionMembershipReader>.Instance : loggerFactory.CreateLogger<StateSubactionMembershipReader>();
@@ -187,6 +189,10 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -207,6 +213,10 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -223,6 +233,10 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -233,6 +247,10 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -305,7 +323,14 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +342,14 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +361,14 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (StateSubactionKind)Enum.Parse(typeof(StateSubactionKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(StateSubactionKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (StateSubactionKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -343,8 +382,14 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -364,8 +409,14 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -385,8 +436,14 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -406,8 +463,14 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -425,12 +488,23 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading StateSubactionMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -555,6 +629,10 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -575,6 +653,10 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -591,6 +673,10 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -601,6 +687,10 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -673,7 +763,14 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,7 +782,14 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -697,7 +801,14 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (StateSubactionKind)Enum.Parse(typeof(StateSubactionKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(StateSubactionKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (StateSubactionKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -711,8 +822,14 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -732,8 +849,14 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -753,8 +876,14 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -774,8 +903,14 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -793,12 +928,23 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading StateSubactionMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs
index a820b8387..c5f6ac0a0 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs
@@ -65,6 +65,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -89,6 +90,7 @@ public class StateUsageReader : XmiDataReader<IStateUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public StateUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StateUsageReader>.Instance : loggerFactory.CreateLogger<StateUsageReader>();
@@ -320,6 +322,10 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -336,6 +342,10 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -396,7 +406,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -420,7 +437,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -432,7 +456,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -444,7 +475,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -456,7 +494,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -468,7 +513,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -480,7 +532,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -492,7 +551,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -504,7 +570,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -516,7 +589,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isParallelValue))
                                     {
-                                        poco.IsParallel = bool.Parse(isParallelValue);
+                                        if (bool.TryParse(isParallelValue, out var isParallelValueAsBool))
+                                        {
+                                            poco.IsParallel = isParallelValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isParallel' on element {ElementId}", isParallelValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -528,7 +608,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -540,7 +627,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -552,7 +646,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -564,7 +665,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -578,8 +686,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -599,8 +713,14 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -618,12 +738,23 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading StateUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -858,6 +989,10 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -874,6 +1009,10 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -934,7 +1073,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -958,7 +1104,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -970,7 +1123,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -982,7 +1142,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -994,7 +1161,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1006,7 +1180,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1018,7 +1199,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1030,7 +1218,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1042,7 +1237,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1054,7 +1256,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isParallelValue))
                                     {
-                                        poco.IsParallel = bool.Parse(isParallelValue);
+                                        if (bool.TryParse(isParallelValue, out var isParallelValueAsBool))
+                                        {
+                                            poco.IsParallel = isParallelValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isParallel' on element {ElementId}", isParallelValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1066,7 +1275,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1078,7 +1294,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1090,7 +1313,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1102,7 +1332,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1116,8 +1353,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1137,8 +1380,14 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1156,12 +1405,23 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading StateUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs
index 3269930e8..fc67aa991 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class StepReader : XmiDataReader<IStep>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public StepReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StepReader>.Instance : loggerFactory.CreateLogger<StepReader>();
@@ -275,6 +277,10 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -291,6 +297,10 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -341,7 +351,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -365,7 +382,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -377,7 +401,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -389,7 +420,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -401,7 +439,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -413,7 +458,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -425,7 +477,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -437,7 +496,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -449,7 +515,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -461,7 +534,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -473,7 +553,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,7 +572,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -499,8 +593,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -520,8 +620,14 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -533,6 +639,10 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Step at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -747,6 +857,10 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -763,6 +877,10 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -813,7 +931,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -837,7 +962,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -849,7 +981,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -861,7 +1000,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -873,7 +1019,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -885,7 +1038,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -897,7 +1057,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -909,7 +1076,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -921,7 +1095,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -933,7 +1114,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -945,7 +1133,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -957,7 +1152,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -971,8 +1173,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -992,8 +1200,14 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1005,6 +1219,10 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Step at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs
index fdead9644..e2cf72fec 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Structures;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class StructureReader : XmiDataReader<IStructure>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public StructureReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<StructureReader>.Instance : loggerFactory.CreateLogger<StructureReader>();
@@ -186,6 +188,10 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -202,6 +208,10 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -264,7 +274,14 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -276,7 +293,14 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -288,7 +312,14 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -302,8 +333,14 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -323,8 +360,14 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -336,6 +379,10 @@ public override IStructure Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Structure at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -460,6 +507,10 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -476,6 +527,10 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -538,7 +593,14 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -550,7 +612,14 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -562,7 +631,14 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -576,8 +652,14 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,8 +679,14 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -610,6 +698,10 @@ public override async Task<IStructure> ReadAsync(XmlReader xmiReader, Uri curren
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Structure at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs
index b31689e64..488981a00 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Classifiers;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class SubclassificationReader : XmiDataReader<ISubclassification>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SubclassificationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SubclassificationReader>.Instance : loggerFactory.CreateLogger<SubclassificationReader>();
@@ -173,6 +175,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -193,6 +199,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -209,6 +219,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -219,6 +233,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var subclassifierXmlAttribute = xmiReader.GetAttribute("subclassifier");
@@ -229,6 +247,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'subclassifier' on element {ElementId}", subclassifierXmlAttribute, poco.Id);
+                    }
                 }
 
                 var superclassifierXmlAttribute = xmiReader.GetAttribute("superclassifier");
@@ -239,6 +261,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'superclassifier' on element {ElementId}", superclassifierXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -301,7 +327,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -313,7 +346,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -327,8 +367,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -348,8 +394,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -369,8 +421,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -390,8 +448,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -411,8 +475,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var subclassifierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var subclassifierId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'subclassifier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -432,8 +502,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var superclassifierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var superclassifierId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'superclassifier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -445,6 +521,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Subclassification at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -559,6 +639,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -579,6 +663,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -595,6 +683,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -605,6 +697,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var subclassifierXmlAttribute = xmiReader.GetAttribute("subclassifier");
@@ -615,6 +711,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'subclassifier' on element {ElementId}", subclassifierXmlAttribute, poco.Id);
+                    }
                 }
 
                 var superclassifierXmlAttribute = xmiReader.GetAttribute("superclassifier");
@@ -625,6 +725,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'superclassifier' on element {ElementId}", superclassifierXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -687,7 +791,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -699,7 +810,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -713,8 +831,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -734,8 +858,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -755,8 +885,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -776,8 +912,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -797,8 +939,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var subclassifierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var subclassifierId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'subclassifier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -818,8 +966,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var superclassifierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var superclassifierId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'superclassifier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -831,6 +985,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Subclassification at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs
index 75b265573..31971fc60 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class SubjectMembershipReader : XmiDataReader<ISubjectMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SubjectMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SubjectMembershipReader>.Instance : loggerFactory.CreateLogger<SubjectMembershipReader>();
@@ -177,6 +179,10 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -197,6 +203,10 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -213,6 +223,10 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -223,6 +237,10 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -295,7 +313,14 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -307,7 +332,14 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -321,8 +353,14 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -342,8 +380,14 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -363,8 +407,14 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -384,8 +434,14 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -403,12 +459,23 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SubjectMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -523,6 +590,10 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -543,6 +614,10 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -559,6 +634,10 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -569,6 +648,10 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -641,7 +724,14 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -653,7 +743,14 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -667,8 +764,14 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -688,8 +791,14 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -709,8 +818,14 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -730,8 +845,14 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -749,12 +870,23 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SubjectMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs
index 84ba820da..655c624bf 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class SubsettingReader : XmiDataReader<ISubsetting>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SubsettingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SubsettingReader>.Instance : loggerFactory.CreateLogger<SubsettingReader>();
@@ -173,6 +175,10 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -193,6 +199,10 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -209,6 +219,10 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -219,6 +233,10 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var subsettedFeatureXmlAttribute = xmiReader.GetAttribute("subsettedFeature");
@@ -229,6 +247,10 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettedFeature", subsettedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'subsettedFeature' on element {ElementId}", subsettedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 var subsettingFeatureXmlAttribute = xmiReader.GetAttribute("subsettingFeature");
@@ -239,6 +261,10 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettingFeature", subsettingFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'subsettingFeature' on element {ElementId}", subsettingFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -301,7 +327,14 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -313,7 +346,14 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -327,8 +367,14 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -348,8 +394,14 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -369,8 +421,14 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -390,8 +448,14 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -411,8 +475,14 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var subsettedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettedFeature", subsettedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var subsettedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettedFeature", subsettedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'subsettedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -432,8 +502,14 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var subsettingFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettingFeature", subsettingFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var subsettingFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettingFeature", subsettingFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'subsettingFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -445,6 +521,10 @@ public override ISubsetting Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Subsetting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -559,6 +639,10 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -579,6 +663,10 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -595,6 +683,10 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -605,6 +697,10 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var subsettedFeatureXmlAttribute = xmiReader.GetAttribute("subsettedFeature");
@@ -615,6 +711,10 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettedFeature", subsettedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'subsettedFeature' on element {ElementId}", subsettedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 var subsettingFeatureXmlAttribute = xmiReader.GetAttribute("subsettingFeature");
@@ -625,6 +725,10 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettingFeature", subsettingFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'subsettingFeature' on element {ElementId}", subsettingFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -687,7 +791,14 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -699,7 +810,14 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -713,8 +831,14 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -734,8 +858,14 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -755,8 +885,14 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -776,8 +912,14 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -797,8 +939,14 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var subsettedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettedFeature", subsettedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var subsettedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettedFeature", subsettedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'subsettedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -818,8 +966,14 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var subsettingFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettingFeature", subsettingFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var subsettingFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subsettingFeature", subsettingFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'subsettingFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -831,6 +985,10 @@ public override async Task<ISubsetting> ReadAsync(XmlReader xmiReader, Uri curre
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Subsetting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs
index b631760d7..bfa60ebfe 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs
@@ -64,6 +64,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Connections;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -88,6 +89,7 @@ public class SuccessionAsUsageReader : XmiDataReader<ISuccessionAsUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SuccessionAsUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SuccessionAsUsageReader>.Instance : loggerFactory.CreateLogger<SuccessionAsUsageReader>();
@@ -309,6 +311,10 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -329,6 +335,10 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -345,6 +355,10 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -355,6 +369,10 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -405,7 +423,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -429,7 +454,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -441,7 +473,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -453,7 +492,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -465,7 +511,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -477,7 +530,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -489,7 +549,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,7 +568,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -513,7 +587,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -525,7 +606,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -537,7 +625,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -549,7 +644,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -561,7 +663,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -575,8 +684,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -596,8 +711,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -617,8 +738,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -638,8 +765,14 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -651,6 +784,10 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SuccessionAsUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -875,6 +1012,10 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -895,6 +1036,10 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -911,6 +1056,10 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -921,6 +1070,10 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -971,7 +1124,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -995,7 +1155,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1007,7 +1174,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1019,7 +1193,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1031,7 +1212,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1043,7 +1231,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1055,7 +1250,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1067,7 +1269,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1079,7 +1288,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1091,7 +1307,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1103,7 +1326,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1115,7 +1345,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1127,7 +1364,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1141,8 +1385,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1162,8 +1412,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1183,8 +1439,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1204,8 +1466,14 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1217,6 +1485,10 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SuccessionAsUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs
index 35089b1d4..4ef0c2686 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Interactions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -68,6 +69,7 @@ public class SuccessionFlowReader : XmiDataReader<ISuccessionFlow>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SuccessionFlowReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SuccessionFlowReader>.Instance : loggerFactory.CreateLogger<SuccessionFlowReader>();
@@ -289,6 +291,10 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -309,6 +315,10 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -325,6 +335,10 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -335,6 +349,10 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -385,7 +403,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -409,7 +434,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -421,7 +453,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -433,7 +472,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -445,7 +491,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -457,7 +510,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -469,7 +529,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -481,7 +548,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -493,7 +567,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -505,7 +586,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -517,7 +605,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -529,7 +624,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -541,7 +643,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -555,8 +664,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -576,8 +691,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,8 +718,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -618,8 +745,14 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -631,6 +764,10 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SuccessionFlow at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -855,6 +992,10 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -875,6 +1016,10 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -891,6 +1036,10 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -901,6 +1050,10 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -951,7 +1104,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1135,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1154,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1173,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1192,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1211,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1230,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1249,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1268,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1071,7 +1287,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1083,7 +1306,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1095,7 +1325,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1107,7 +1344,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1121,8 +1365,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1142,8 +1392,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1163,8 +1419,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1184,8 +1446,14 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1197,6 +1465,10 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SuccessionFlow at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs
index af918d310..fdf7bb0f5 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs
@@ -68,6 +68,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Flows;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -92,6 +93,7 @@ public class SuccessionFlowUsageReader : XmiDataReader<ISuccessionFlowUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SuccessionFlowUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SuccessionFlowUsageReader>.Instance : loggerFactory.CreateLogger<SuccessionFlowUsageReader>();
@@ -323,6 +325,10 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -343,6 +349,10 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -359,6 +369,10 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -369,6 +383,10 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -429,7 +447,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -453,7 +478,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -465,7 +497,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -477,7 +516,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -489,7 +535,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -501,7 +554,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -513,7 +573,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -525,7 +592,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -537,7 +611,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -549,7 +630,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -561,7 +649,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -573,7 +668,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -585,7 +687,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -597,7 +706,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -611,8 +727,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -632,8 +754,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -653,8 +781,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -674,8 +808,14 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -693,12 +833,23 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SuccessionFlowUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -933,6 +1084,10 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -953,6 +1108,10 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -969,6 +1128,10 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -979,6 +1142,10 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -1039,7 +1206,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1063,7 +1237,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1075,7 +1256,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1087,7 +1275,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1099,7 +1294,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1111,7 +1313,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1123,7 +1332,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1135,7 +1351,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1147,7 +1370,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1159,7 +1389,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1171,7 +1408,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1183,7 +1427,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1195,7 +1446,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1207,7 +1465,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1221,8 +1486,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1242,8 +1513,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1263,8 +1540,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1284,8 +1567,14 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1303,12 +1592,23 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SuccessionFlowUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs
index b811568cd..bec906b67 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs
@@ -41,6 +41,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Connectors;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -65,6 +66,7 @@ public class SuccessionReader : XmiDataReader<ISuccession>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public SuccessionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<SuccessionReader>.Instance : loggerFactory.CreateLogger<SuccessionReader>();
@@ -286,6 +288,10 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -306,6 +312,10 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -322,6 +332,10 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -332,6 +346,10 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -382,7 +400,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -406,7 +431,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -418,7 +450,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -430,7 +469,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -442,7 +488,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -454,7 +507,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -466,7 +526,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -478,7 +545,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -490,7 +564,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -502,7 +583,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -514,7 +602,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -526,7 +621,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -538,7 +640,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -552,8 +661,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -573,8 +688,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -594,8 +715,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -615,8 +742,14 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -628,6 +761,10 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Succession at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -852,6 +989,10 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -872,6 +1013,10 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -888,6 +1033,10 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -898,6 +1047,10 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -948,7 +1101,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -972,7 +1132,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -984,7 +1151,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -996,7 +1170,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1008,7 +1189,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1020,7 +1208,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1032,7 +1227,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1044,7 +1246,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1056,7 +1265,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1068,7 +1284,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1080,7 +1303,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1092,7 +1322,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1104,7 +1341,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1118,8 +1362,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1139,8 +1389,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1160,8 +1416,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1181,8 +1443,14 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1194,6 +1462,10 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Succession at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs
index 27785728d..c538acf8a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class TerminateActionUsageReader : XmiDataReader<ITerminateActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public TerminateActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TerminateActionUsageReader>.Instance : loggerFactory.CreateLogger<TerminateActionUsageReader>();
@@ -311,6 +313,10 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TerminateActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TerminateActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs
index e5c789080..e7cfeb3a7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs
@@ -36,6 +36,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -60,6 +61,7 @@ public class TextualRepresentationReader : XmiDataReader<ITextualRepresentation>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public TextualRepresentationReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TextualRepresentationReader>.Instance : loggerFactory.CreateLogger<TextualRepresentationReader>();
@@ -175,6 +177,10 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -191,6 +197,10 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -265,7 +275,14 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -291,8 +308,14 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -312,8 +335,14 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -325,6 +354,10 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TextualRepresentation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -443,6 +476,10 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -459,6 +496,10 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -533,7 +574,14 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -559,8 +607,14 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -580,8 +634,14 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -593,6 +653,10 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TextualRepresentation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs
index f2a2fa7e5..54fbeab58 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs
@@ -42,6 +42,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -66,6 +67,7 @@ public class TransitionFeatureMembershipReader : XmiDataReader<ITransitionFeatur
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public TransitionFeatureMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TransitionFeatureMembershipReader>.Instance : loggerFactory.CreateLogger<TransitionFeatureMembershipReader>();
@@ -187,6 +189,10 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -207,6 +213,10 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -223,6 +233,10 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -233,6 +247,10 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -305,7 +323,14 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +342,14 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +361,14 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (TransitionFeatureKind)Enum.Parse(typeof(TransitionFeatureKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(TransitionFeatureKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (TransitionFeatureKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -343,8 +382,14 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -364,8 +409,14 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -385,8 +436,14 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -406,8 +463,14 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -425,12 +488,23 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TransitionFeatureMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -555,6 +629,10 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -575,6 +653,10 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -591,6 +673,10 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -601,6 +687,10 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -673,7 +763,14 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,7 +782,14 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -697,7 +801,14 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (TransitionFeatureKind)Enum.Parse(typeof(TransitionFeatureKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(TransitionFeatureKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (TransitionFeatureKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -711,8 +822,14 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -732,8 +849,14 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -753,8 +876,14 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -774,8 +903,14 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -793,12 +928,23 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TransitionFeatureMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs
index 68bca9727..84630f4fb 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs
@@ -67,6 +67,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.States;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -91,6 +92,7 @@ public class TransitionUsageReader : XmiDataReader<ITransitionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public TransitionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TransitionUsageReader>.Instance : loggerFactory.CreateLogger<TransitionUsageReader>();
@@ -312,6 +314,10 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -328,6 +334,10 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -388,7 +398,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -412,7 +429,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -424,7 +448,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -436,7 +467,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -448,7 +486,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -460,7 +505,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -472,7 +524,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -484,7 +543,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -496,7 +562,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -508,7 +581,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -520,7 +600,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -532,7 +619,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -544,7 +638,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -558,8 +659,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -579,8 +686,14 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -598,12 +711,23 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TransitionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -828,6 +952,10 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -844,6 +972,10 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -904,7 +1036,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -928,7 +1067,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -940,7 +1086,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -952,7 +1105,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -964,7 +1124,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -976,7 +1143,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -988,7 +1162,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1000,7 +1181,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1012,7 +1200,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1024,7 +1219,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1036,7 +1238,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1048,7 +1257,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1060,7 +1276,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1074,8 +1297,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1095,8 +1324,14 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1114,12 +1349,23 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TransitionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs
index ac432b068..b57c46dd8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs
@@ -44,6 +44,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -68,6 +69,7 @@ public class TriggerInvocationExpressionReader : XmiDataReader<ITriggerInvocatio
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public TriggerInvocationExpressionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TriggerInvocationExpressionReader>.Instance : loggerFactory.CreateLogger<TriggerInvocationExpressionReader>();
@@ -289,6 +291,10 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -305,6 +311,10 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -355,7 +365,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -379,7 +396,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,7 +415,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -403,7 +434,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -415,7 +453,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -427,7 +472,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -439,7 +491,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -451,7 +510,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -463,7 +529,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -475,7 +548,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -487,7 +567,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -499,7 +586,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -511,7 +605,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (TriggerKind)Enum.Parse(typeof(TriggerKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(TriggerKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (TriggerKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -525,8 +626,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -546,8 +653,14 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -559,6 +672,10 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TriggerInvocationExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -783,6 +900,10 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -799,6 +920,10 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -849,7 +974,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -873,7 +1005,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -885,7 +1024,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -897,7 +1043,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -909,7 +1062,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -921,7 +1081,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -933,7 +1100,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -945,7 +1119,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -957,7 +1138,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -969,7 +1157,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -981,7 +1176,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -993,7 +1195,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1005,7 +1214,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (TriggerKind)Enum.Parse(typeof(TriggerKind), kindValue, true);
+                                        if (Enum.TryParse(typeof(TriggerKind), kindValue, true, out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = (TriggerKind)kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1019,8 +1235,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1040,8 +1262,14 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1053,6 +1281,10 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TriggerInvocationExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs
index 3bb5d01d6..6d26aecdf 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class TypeFeaturingReader : XmiDataReader<ITypeFeaturing>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public TypeFeaturingReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TypeFeaturingReader>.Instance : loggerFactory.CreateLogger<TypeFeaturingReader>();
@@ -149,6 +151,10 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureOfType", featureOfTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'featureOfType' on element {ElementId}", featureOfTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var featuringTypeXmlAttribute = xmiReader.GetAttribute("featuringType");
@@ -159,6 +165,10 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featuringType", featuringTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'featuringType' on element {ElementId}", featuringTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -193,6 +203,10 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -213,6 +227,10 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -229,6 +247,10 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -239,6 +261,10 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -303,8 +329,14 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var featureOfTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureOfType", featureOfTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var featureOfTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureOfType", featureOfTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'featureOfType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -324,8 +356,14 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var featuringTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featuringType", featuringTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var featuringTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featuringType", featuringTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'featuringType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -343,7 +381,14 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -355,7 +400,14 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -369,8 +421,14 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -390,8 +448,14 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -411,8 +475,14 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -432,8 +502,14 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -445,6 +521,10 @@ public override ITypeFeaturing Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TypeFeaturing at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -535,6 +615,10 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureOfType", featureOfTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'featureOfType' on element {ElementId}", featureOfTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var featuringTypeXmlAttribute = xmiReader.GetAttribute("featuringType");
@@ -545,6 +629,10 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featuringType", featuringTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'featuringType' on element {ElementId}", featuringTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var isImpliedXmlAttribute = xmiReader.GetAttribute("isImplied");
@@ -579,6 +667,10 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -599,6 +691,10 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -615,6 +711,10 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -625,6 +725,10 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -689,8 +793,14 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var featureOfTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureOfType", featureOfTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var featureOfTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featureOfType", featureOfTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'featureOfType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -710,8 +820,14 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var featuringTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featuringType", featuringTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var featuringTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "featuringType", featuringTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'featuringType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -729,7 +845,14 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -741,7 +864,14 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -755,8 +885,14 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -776,8 +912,14 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -797,8 +939,14 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -818,8 +966,14 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -831,6 +985,10 @@ public override async Task<ITypeFeaturing> ReadAsync(XmlReader xmiReader, Uri cu
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TypeFeaturing at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs
index 468f47790..e807265c1 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class TypeReader : XmiDataReader<IType>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public TypeReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<TypeReader>.Instance : loggerFactory.CreateLogger<TypeReader>();
@@ -183,6 +185,10 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -199,6 +205,10 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -261,7 +271,14 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -273,7 +290,14 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -285,7 +309,14 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -299,8 +330,14 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -320,8 +357,14 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -333,6 +376,10 @@ public override IType Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Type at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -457,6 +504,10 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -473,6 +524,10 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -535,7 +590,14 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -547,7 +609,14 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -559,7 +628,14 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -573,8 +649,14 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -594,8 +676,14 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -607,6 +695,10 @@ public override async Task<IType> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Type at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs
index 2b5af708b..2cc8ba40f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs
@@ -37,6 +37,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -61,6 +62,7 @@ public class UnioningReader : XmiDataReader<IUnioning>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public UnioningReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<UnioningReader>.Instance : loggerFactory.CreateLogger<UnioningReader>();
@@ -172,6 +174,10 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -192,6 +198,10 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -208,6 +218,10 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -218,6 +232,10 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var unioningTypeXmlAttribute = xmiReader.GetAttribute("unioningType");
@@ -228,6 +246,10 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "unioningType", unioningTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'unioningType' on element {ElementId}", unioningTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -290,7 +312,14 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -302,7 +331,14 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -316,8 +352,14 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -337,8 +379,14 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -358,8 +406,14 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -379,8 +433,14 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,8 +460,14 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var unioningTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "unioningType", unioningTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var unioningTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "unioningType", unioningTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'unioningType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -413,6 +479,10 @@ public override IUnioning Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Unioning at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -527,6 +597,10 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -547,6 +621,10 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -563,6 +641,10 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -573,6 +655,10 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var unioningTypeXmlAttribute = xmiReader.GetAttribute("unioningType");
@@ -583,6 +669,10 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "unioningType", unioningTypeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'unioningType' on element {ElementId}", unioningTypeXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -645,7 +735,14 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -657,7 +754,14 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -671,8 +775,14 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -692,8 +802,14 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -713,8 +829,14 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -734,8 +856,14 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -755,8 +883,14 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var unioningTypeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "unioningType", unioningTypeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var unioningTypeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "unioningType", unioningTypeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'unioningType' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -768,6 +902,10 @@ public override async Task<IUnioning> ReadAsync(XmlReader xmiReader, Uri current
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Unioning at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs
index 6ebda1fe8..7d5179a64 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class UsageReader : XmiDataReader<IUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public UsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<UsageReader>.Instance : loggerFactory.CreateLogger<UsageReader>();
@@ -297,6 +299,10 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -313,6 +319,10 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -363,7 +373,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -387,7 +404,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -399,7 +423,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +442,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +461,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +480,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +499,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +518,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +537,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +556,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +575,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +594,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -521,8 +615,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -542,8 +642,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -555,6 +661,10 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Usage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -769,6 +879,10 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -785,6 +899,10 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -835,7 +953,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -859,7 +984,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -871,7 +1003,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -883,7 +1022,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -895,7 +1041,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -907,7 +1060,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -919,7 +1079,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -931,7 +1098,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -943,7 +1117,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -955,7 +1136,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -967,7 +1155,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -979,7 +1174,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -993,8 +1195,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1014,8 +1222,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1027,6 +1241,10 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Usage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs
index a4772d718..109dde1d2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class UseCaseDefinitionReader : XmiDataReader<IUseCaseDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public UseCaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<UseCaseDefinitionReader>.Instance : loggerFactory.CreateLogger<UseCaseDefinitionReader>();
@@ -228,6 +230,10 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -244,6 +250,10 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -306,7 +316,14 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +335,14 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +354,14 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -342,7 +373,14 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -354,7 +392,14 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -368,8 +413,14 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -389,8 +440,14 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,6 +459,10 @@ public override IUseCaseDefinition Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading UseCaseDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -546,6 +607,10 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -562,6 +627,10 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -624,7 +693,14 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -636,7 +712,14 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -648,7 +731,14 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -660,7 +750,14 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -672,7 +769,14 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -686,8 +790,14 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,8 +817,14 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -720,6 +836,10 @@ public override async Task<IUseCaseDefinition> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading UseCaseDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs
index be0172fbe..840b31436 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.UseCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class UseCaseUsageReader : XmiDataReader<IUseCaseUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public UseCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<UseCaseUsageReader>.Instance : loggerFactory.CreateLogger<UseCaseUsageReader>();
@@ -311,6 +313,10 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading UseCaseUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading UseCaseUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs
index 0c9183d87..7894b094d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs
@@ -38,6 +38,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -62,6 +63,7 @@ public class VariantMembershipReader : XmiDataReader<IVariantMembership>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public VariantMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<VariantMembershipReader>.Instance : loggerFactory.CreateLogger<VariantMembershipReader>();
@@ -173,6 +175,10 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -193,6 +199,10 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -209,6 +219,10 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -219,6 +233,10 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -291,7 +309,14 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -303,7 +328,14 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,8 +349,14 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -338,8 +376,14 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -359,8 +403,14 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -380,8 +430,14 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -399,12 +455,23 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading VariantMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -519,6 +586,10 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -539,6 +610,10 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -555,6 +630,10 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -565,6 +644,10 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -637,7 +720,14 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -649,7 +739,14 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -663,8 +760,14 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -684,8 +787,14 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -705,8 +814,14 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -726,8 +841,14 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -745,12 +866,23 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading VariantMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs
index bc2803928..f7e37695c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class VerificationCaseDefinitionReader : XmiDataReader<IVerificationCaseD
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public VerificationCaseDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<VerificationCaseDefinitionReader>.Instance : loggerFactory.CreateLogger<VerificationCaseDefinitionReader>();
@@ -228,6 +230,10 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -244,6 +250,10 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -306,7 +316,14 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +335,14 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +354,14 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -342,7 +373,14 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -354,7 +392,14 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -368,8 +413,14 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -389,8 +440,14 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,6 +459,10 @@ public override IVerificationCaseDefinition Read(XmlReader xmiReader, Uri curren
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading VerificationCaseDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -546,6 +607,10 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -562,6 +627,10 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -624,7 +693,14 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -636,7 +712,14 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -648,7 +731,14 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -660,7 +750,14 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -672,7 +769,14 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -686,8 +790,14 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,8 +817,14 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -720,6 +836,10 @@ public override async Task<IVerificationCaseDefinition> ReadAsync(XmlReader xmiR
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading VerificationCaseDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs
index 5a0696ab6..8004a6243 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class VerificationCaseUsageReader : XmiDataReader<IVerificationCaseUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public VerificationCaseUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<VerificationCaseUsageReader>.Instance : loggerFactory.CreateLogger<VerificationCaseUsageReader>();
@@ -311,6 +313,10 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading VerificationCaseUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading VerificationCaseUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs
index c83c98107..e5bd9ce6f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs
@@ -62,6 +62,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -86,6 +87,7 @@ public class ViewDefinitionReader : XmiDataReader<IViewDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ViewDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ViewDefinitionReader>.Instance : loggerFactory.CreateLogger<ViewDefinitionReader>();
@@ -227,6 +229,10 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -243,6 +249,10 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -305,7 +315,14 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +334,14 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +353,14 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -341,7 +372,14 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -353,7 +391,14 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -367,8 +412,14 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -388,8 +439,14 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,6 +458,10 @@ public override IViewDefinition Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ViewDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -545,6 +606,10 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -561,6 +626,10 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -623,7 +692,14 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -635,7 +711,14 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -647,7 +730,14 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -659,7 +749,14 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -671,7 +768,14 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,8 +789,14 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -706,8 +816,14 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -719,6 +835,10 @@ public override async Task<IViewDefinition> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ViewDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs
index 373b13f00..9c4b494e8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs
@@ -40,6 +40,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -64,6 +65,7 @@ public class ViewRenderingMembershipReader : XmiDataReader<IViewRenderingMembers
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ViewRenderingMembershipReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ViewRenderingMembershipReader>.Instance : loggerFactory.CreateLogger<ViewRenderingMembershipReader>();
@@ -175,6 +177,10 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -195,6 +201,10 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -211,6 +221,10 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -221,6 +235,10 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -293,7 +311,14 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -305,7 +330,14 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -319,8 +351,14 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -340,8 +378,14 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -361,8 +405,14 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -382,8 +432,14 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -401,12 +457,23 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ViewRenderingMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -521,6 +588,10 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -541,6 +612,10 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -557,6 +632,10 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -567,6 +646,10 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
@@ -639,7 +722,14 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -651,7 +741,14 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -665,8 +762,14 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -686,8 +789,14 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -707,8 +816,14 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -728,8 +843,14 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -747,12 +868,23 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ViewRenderingMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs
index adf2753b0..90e70f170 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class ViewUsageReader : XmiDataReader<IViewUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ViewUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ViewUsageReader>.Instance : loggerFactory.CreateLogger<ViewUsageReader>();
@@ -311,6 +313,10 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ViewUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ViewUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs
index 03eda3e79..c16812481 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs
@@ -63,6 +63,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -87,6 +88,7 @@ public class ViewpointDefinitionReader : XmiDataReader<IViewpointDefinition>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ViewpointDefinitionReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ViewpointDefinitionReader>.Instance : loggerFactory.CreateLogger<ViewpointDefinitionReader>();
@@ -221,6 +223,10 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -237,6 +243,10 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var reqIdXmlAttribute = xmiReader.GetAttribute("reqId");
@@ -294,7 +304,14 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -306,7 +323,14 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,7 +342,14 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -330,7 +361,14 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -342,7 +380,14 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -356,8 +401,14 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -377,8 +428,14 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -402,6 +459,10 @@ public override IViewpointDefinition Read(XmlReader xmiReader, Uri currentLocati
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ViewpointDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -539,6 +600,10 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -555,6 +620,10 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var reqIdXmlAttribute = xmiReader.GetAttribute("reqId");
@@ -612,7 +681,14 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -624,7 +700,14 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -636,7 +719,14 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -648,7 +738,14 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -660,7 +757,14 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -674,8 +778,14 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -695,8 +805,14 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -720,6 +836,10 @@ public override async Task<IViewpointDefinition> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ViewpointDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs
index b9fbaff32..e5fa4a6a6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.UseCases;
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class ViewpointUsageReader : XmiDataReader<IViewpointUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public ViewpointUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<ViewpointUsageReader>.Instance : loggerFactory.CreateLogger<ViewpointUsageReader>();
@@ -304,6 +306,10 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -320,6 +326,10 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -375,7 +385,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -399,7 +416,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +435,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +454,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +473,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +492,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +511,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +530,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +549,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +568,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +587,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +606,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +625,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -545,8 +646,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -566,8 +673,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -585,7 +698,14 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -603,6 +723,10 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ViewpointUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -820,6 +944,10 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -836,6 +964,10 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -891,7 +1023,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -915,7 +1054,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1073,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1092,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1111,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1130,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1149,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1168,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1187,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1206,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1225,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1244,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1263,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1061,8 +1284,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1082,8 +1311,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1101,7 +1336,14 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1119,6 +1361,10 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ViewpointUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs
index 209690a1c..3bc1984dc 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs
@@ -66,6 +66,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using SysML2.NET.Core.POCO.Systems.VerificationCases;
     using SysML2.NET.Core.POCO.Systems.Views;
     using SysML2.NET.Core.POCO.Systems.Actions;
+    using SysML2.NET.Core.POCO.Root.Elements;
 
     /// <summary>
     /// The purpose of the <see cref="{this.Name}}Reader" /> is to read an instance of <see cref="I{this.Name}}" />
@@ -90,6 +91,7 @@ public class WhileLoopActionUsageReader : XmiDataReader<IWhileLoopActionUsage>
         /// </param>
         /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService"/> used to register and process external references</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory" /> used to set up logging</param>
+        /// <param name="elementOriginMap">The optional <see cref="IXmiElementOriginMap"/> used to track element-to-file associations</param>
         public WhileLoopActionUsageReader(IXmiDataCache cache, IXmiDataReaderFacade xmiDataReaderFacade, IExternalReferenceService externalReferenceService, ILoggerFactory loggerFactory, IXmiElementOriginMap elementOriginMap = null) : base(cache, xmiDataReaderFacade, externalReferenceService, loggerFactory, elementOriginMap)
         {
             this.logger = loggerFactory == null ? NullLogger<WhileLoopActionUsageReader>.Instance : loggerFactory.CreateLogger<WhileLoopActionUsageReader>();
@@ -311,6 +313,10 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +333,10 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -387,7 +397,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +428,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +447,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +466,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +485,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +504,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +523,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +542,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +561,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +580,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +599,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +618,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +637,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +658,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +685,14 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -597,12 +710,23 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading WhileLoopActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -827,6 +951,10 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -843,6 +971,10 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
@@ -903,7 +1035,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1066,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1085,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1104,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1123,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1142,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1161,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -999,7 +1180,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1011,7 +1199,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1023,7 +1218,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1035,7 +1237,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1047,7 +1256,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1059,7 +1275,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,8 +1296,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1094,8 +1323,14 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1113,12 +1348,23 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading WhileLoopActionUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.Serializer.Xmi/Serializer.cs b/SysML2.NET.Serializer.Xmi/Serializer.cs
index c797628a0..e082e05bf 100644
--- a/SysML2.NET.Serializer.Xmi/Serializer.cs
+++ b/SysML2.NET.Serializer.Xmi/Serializer.cs
@@ -72,12 +72,13 @@ public class Serializer : ISerializer
         private readonly IXmiDataWriterFacade xmiWriterFacade;
 
         /// <summary>Initializes a new instance of the <see cref="Serializer"></see> class.</summary>
+        /// <param name="xmiWriterFacade">The injected <see cref="IXmiDataWriterFacade"/> to dispatch element writing</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory " /> used to set up logging</param>
-        public Serializer(ILoggerFactory loggerFactory)
+        public Serializer(IXmiDataWriterFacade xmiWriterFacade, ILoggerFactory loggerFactory)
         {
             this.loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
             this.logger = this.loggerFactory.CreateLogger<Serializer>();
-            this.xmiWriterFacade = new XmiDataWriterFacade(this.loggerFactory);
+            this.xmiWriterFacade = xmiWriterFacade ?? throw new ArgumentNullException(nameof(xmiWriterFacade));
         }
 
         /// <summary>
@@ -203,6 +204,10 @@ public void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOrig
 
             this.logger.LogInformation("Starting multi-file XMI serialization for {FileCount} files", sourceFiles.Count);
 
+            // Build a flat index of all namespaces for O(1) lookup instead of recursive tree walk per file
+            var namespaceIndex = new System.Collections.Generic.Dictionary<Guid, INamespace>();
+            BuildNamespaceIndex(rootNamespace, namespaceIndex);
+
             foreach (var sourceFile in sourceFiles)
             {
                 var rootNamespaceId = elementOriginMap.GetRootNamespaceId(sourceFile);
@@ -221,9 +226,7 @@ public void Serialize(INamespace rootNamespace, IXmiElementOriginMap elementOrig
                 this.logger.LogInformation("Writing {FileName}", fileName);
 
                 // Find the namespace POCO for this file's root namespace
-                var fileRootNamespace = FindNamespaceById(rootNamespace, rootNamespaceId);
-
-                if (fileRootNamespace == null)
+                if (!namespaceIndex.TryGetValue(rootNamespaceId, out var fileRootNamespace))
                 {
                     this.logger.LogWarning("Could not find namespace with id {NamespaceId} for file {SourceFile}", rootNamespaceId, sourceFile);
                     continue;
@@ -314,46 +317,32 @@ private void WriteNamespaceElement(XmlWriter xmlWriter, INamespace @namespace, I
         }
 
         /// <summary>
-        /// Finds a <see cref="INamespace" /> based on its <see cref="Guid"/>
+        /// Builds a flat index of all <see cref="INamespace"/> instances reachable from the root
         /// </summary>
-        /// <param name="root">The root <see cref="INamespace"/> used as starting point of the find operation</param>
-        /// <param name="id">The identifier <see cref="Guid"/></param>
-        /// <returns>The <see cref="INamespace"/> if found, <c>null</c> otherwise</returns>
-        private static INamespace FindNamespaceById(INamespace root, Guid id)
+        /// <param name="root">The root <see cref="INamespace"/> used as starting point</param>
+        /// <param name="index">The dictionary to populate with namespace id to instance mappings</param>
+        private static void BuildNamespaceIndex(INamespace root, System.Collections.Generic.Dictionary<Guid, INamespace> index)
         {
-            if (root.Id == id)
-            {
-                return root;
-            }
+            index[root.Id] = root;
 
             if (root.OwnedRelationship == null)
             {
-                return null;
+                return;
             }
 
             foreach (var relationship in root.OwnedRelationship)
             {
-                if (relationship is IElement element)
+                if (relationship is IElement element && element.OwnedRelationship != null)
                 {
-                    if (element.OwnedRelationship != null)
+                    foreach (var child in element.OwnedRelationship)
                     {
-                        foreach (var child in element.OwnedRelationship)
+                        if (child is INamespace childNamespace)
                         {
-                            if (child is INamespace childNamespace)
-                            {
-                                var found = FindNamespaceById(childNamespace, id);
-
-                                if (found != null)
-                                {
-                                    return found;
-                                }
-                            }
+                            BuildNamespaceIndex(childNamespace, index);
                         }
                     }
                 }
             }
-
-            return null;
         }
     }
 }
diff --git a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
index 68fc0e8db..526e1d8a7 100644
--- a/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
+++ b/SysML2.NET.Serializer.Xmi/Writers/AutoGenWriters/XmiDataWriterFacade.cs
@@ -40,11 +40,6 @@ namespace SysML2.NET.Serializer.Xmi.Writers
     /// </summary>
     public class XmiDataWriterFacade : IXmiDataWriterFacade
     {
-        /// <summary>
-        /// The <see cref="ILoggerFactory"/> used to set up logging for writer instances
-        /// </summary>
-        private readonly ILoggerFactory loggerFactory;
-
         /// <summary>
         /// A dictionary that contains actions that write <see cref="IData"/> based on a key that represents the POCO type name
         /// </summary>
@@ -61,844 +56,843 @@ public class XmiDataWriterFacade : IXmiDataWriterFacade
         /// <param name="loggerFactory">The <see cref="ILoggerFactory"/> used to set up logging</param>
         public XmiDataWriterFacade(ILoggerFactory loggerFactory)
         {
-            this.loggerFactory = loggerFactory;
+            var acceptActionUsageWriter = new AcceptActionUsageWriter(this, loggerFactory);
+            var actionDefinitionWriter = new ActionDefinitionWriter(this, loggerFactory);
+            var actionUsageWriter = new ActionUsageWriter(this, loggerFactory);
+            var actorMembershipWriter = new ActorMembershipWriter(this, loggerFactory);
+            var allocationDefinitionWriter = new AllocationDefinitionWriter(this, loggerFactory);
+            var allocationUsageWriter = new AllocationUsageWriter(this, loggerFactory);
+            var analysisCaseDefinitionWriter = new AnalysisCaseDefinitionWriter(this, loggerFactory);
+            var analysisCaseUsageWriter = new AnalysisCaseUsageWriter(this, loggerFactory);
+            var annotatingElementWriter = new AnnotatingElementWriter(this, loggerFactory);
+            var annotationWriter = new AnnotationWriter(this, loggerFactory);
+            var assertConstraintUsageWriter = new AssertConstraintUsageWriter(this, loggerFactory);
+            var assignmentActionUsageWriter = new AssignmentActionUsageWriter(this, loggerFactory);
+            var associationWriter = new AssociationWriter(this, loggerFactory);
+            var associationStructureWriter = new AssociationStructureWriter(this, loggerFactory);
+            var attributeDefinitionWriter = new AttributeDefinitionWriter(this, loggerFactory);
+            var attributeUsageWriter = new AttributeUsageWriter(this, loggerFactory);
+            var behaviorWriter = new BehaviorWriter(this, loggerFactory);
+            var bindingConnectorWriter = new BindingConnectorWriter(this, loggerFactory);
+            var bindingConnectorAsUsageWriter = new BindingConnectorAsUsageWriter(this, loggerFactory);
+            var booleanExpressionWriter = new BooleanExpressionWriter(this, loggerFactory);
+            var calculationDefinitionWriter = new CalculationDefinitionWriter(this, loggerFactory);
+            var calculationUsageWriter = new CalculationUsageWriter(this, loggerFactory);
+            var caseDefinitionWriter = new CaseDefinitionWriter(this, loggerFactory);
+            var caseUsageWriter = new CaseUsageWriter(this, loggerFactory);
+            var classWriter = new ClassWriter(this, loggerFactory);
+            var classifierWriter = new ClassifierWriter(this, loggerFactory);
+            var collectExpressionWriter = new CollectExpressionWriter(this, loggerFactory);
+            var commentWriter = new CommentWriter(this, loggerFactory);
+            var concernDefinitionWriter = new ConcernDefinitionWriter(this, loggerFactory);
+            var concernUsageWriter = new ConcernUsageWriter(this, loggerFactory);
+            var conjugatedPortDefinitionWriter = new ConjugatedPortDefinitionWriter(this, loggerFactory);
+            var conjugatedPortTypingWriter = new ConjugatedPortTypingWriter(this, loggerFactory);
+            var conjugationWriter = new ConjugationWriter(this, loggerFactory);
+            var connectionDefinitionWriter = new ConnectionDefinitionWriter(this, loggerFactory);
+            var connectionUsageWriter = new ConnectionUsageWriter(this, loggerFactory);
+            var connectorWriter = new ConnectorWriter(this, loggerFactory);
+            var constraintDefinitionWriter = new ConstraintDefinitionWriter(this, loggerFactory);
+            var constraintUsageWriter = new ConstraintUsageWriter(this, loggerFactory);
+            var constructorExpressionWriter = new ConstructorExpressionWriter(this, loggerFactory);
+            var crossSubsettingWriter = new CrossSubsettingWriter(this, loggerFactory);
+            var dataTypeWriter = new DataTypeWriter(this, loggerFactory);
+            var decisionNodeWriter = new DecisionNodeWriter(this, loggerFactory);
+            var definitionWriter = new DefinitionWriter(this, loggerFactory);
+            var dependencyWriter = new DependencyWriter(this, loggerFactory);
+            var differencingWriter = new DifferencingWriter(this, loggerFactory);
+            var disjoiningWriter = new DisjoiningWriter(this, loggerFactory);
+            var documentationWriter = new DocumentationWriter(this, loggerFactory);
+            var elementFilterMembershipWriter = new ElementFilterMembershipWriter(this, loggerFactory);
+            var endFeatureMembershipWriter = new EndFeatureMembershipWriter(this, loggerFactory);
+            var enumerationDefinitionWriter = new EnumerationDefinitionWriter(this, loggerFactory);
+            var enumerationUsageWriter = new EnumerationUsageWriter(this, loggerFactory);
+            var eventOccurrenceUsageWriter = new EventOccurrenceUsageWriter(this, loggerFactory);
+            var exhibitStateUsageWriter = new ExhibitStateUsageWriter(this, loggerFactory);
+            var expressionWriter = new ExpressionWriter(this, loggerFactory);
+            var featureWriter = new FeatureWriter(this, loggerFactory);
+            var featureChainExpressionWriter = new FeatureChainExpressionWriter(this, loggerFactory);
+            var featureChainingWriter = new FeatureChainingWriter(this, loggerFactory);
+            var featureInvertingWriter = new FeatureInvertingWriter(this, loggerFactory);
+            var featureMembershipWriter = new FeatureMembershipWriter(this, loggerFactory);
+            var featureReferenceExpressionWriter = new FeatureReferenceExpressionWriter(this, loggerFactory);
+            var featureTypingWriter = new FeatureTypingWriter(this, loggerFactory);
+            var featureValueWriter = new FeatureValueWriter(this, loggerFactory);
+            var flowWriter = new FlowWriter(this, loggerFactory);
+            var flowDefinitionWriter = new FlowDefinitionWriter(this, loggerFactory);
+            var flowEndWriter = new FlowEndWriter(this, loggerFactory);
+            var flowUsageWriter = new FlowUsageWriter(this, loggerFactory);
+            var forkNodeWriter = new ForkNodeWriter(this, loggerFactory);
+            var forLoopActionUsageWriter = new ForLoopActionUsageWriter(this, loggerFactory);
+            var framedConcernMembershipWriter = new FramedConcernMembershipWriter(this, loggerFactory);
+            var functionWriter = new FunctionWriter(this, loggerFactory);
+            var ifActionUsageWriter = new IfActionUsageWriter(this, loggerFactory);
+            var includeUseCaseUsageWriter = new IncludeUseCaseUsageWriter(this, loggerFactory);
+            var indexExpressionWriter = new IndexExpressionWriter(this, loggerFactory);
+            var interactionWriter = new InteractionWriter(this, loggerFactory);
+            var interfaceDefinitionWriter = new InterfaceDefinitionWriter(this, loggerFactory);
+            var interfaceUsageWriter = new InterfaceUsageWriter(this, loggerFactory);
+            var intersectingWriter = new IntersectingWriter(this, loggerFactory);
+            var invariantWriter = new InvariantWriter(this, loggerFactory);
+            var invocationExpressionWriter = new InvocationExpressionWriter(this, loggerFactory);
+            var itemDefinitionWriter = new ItemDefinitionWriter(this, loggerFactory);
+            var itemUsageWriter = new ItemUsageWriter(this, loggerFactory);
+            var joinNodeWriter = new JoinNodeWriter(this, loggerFactory);
+            var libraryPackageWriter = new LibraryPackageWriter(this, loggerFactory);
+            var literalBooleanWriter = new LiteralBooleanWriter(this, loggerFactory);
+            var literalExpressionWriter = new LiteralExpressionWriter(this, loggerFactory);
+            var literalInfinityWriter = new LiteralInfinityWriter(this, loggerFactory);
+            var literalIntegerWriter = new LiteralIntegerWriter(this, loggerFactory);
+            var literalRationalWriter = new LiteralRationalWriter(this, loggerFactory);
+            var literalStringWriter = new LiteralStringWriter(this, loggerFactory);
+            var membershipWriter = new MembershipWriter(this, loggerFactory);
+            var membershipExposeWriter = new MembershipExposeWriter(this, loggerFactory);
+            var membershipImportWriter = new MembershipImportWriter(this, loggerFactory);
+            var mergeNodeWriter = new MergeNodeWriter(this, loggerFactory);
+            var metaclassWriter = new MetaclassWriter(this, loggerFactory);
+            var metadataAccessExpressionWriter = new MetadataAccessExpressionWriter(this, loggerFactory);
+            var metadataDefinitionWriter = new MetadataDefinitionWriter(this, loggerFactory);
+            var metadataFeatureWriter = new MetadataFeatureWriter(this, loggerFactory);
+            var metadataUsageWriter = new MetadataUsageWriter(this, loggerFactory);
+            var multiplicityWriter = new MultiplicityWriter(this, loggerFactory);
+            var multiplicityRangeWriter = new MultiplicityRangeWriter(this, loggerFactory);
+            var namespaceWriter = new NamespaceWriter(this, loggerFactory);
+            var namespaceExposeWriter = new NamespaceExposeWriter(this, loggerFactory);
+            var namespaceImportWriter = new NamespaceImportWriter(this, loggerFactory);
+            var nullExpressionWriter = new NullExpressionWriter(this, loggerFactory);
+            var objectiveMembershipWriter = new ObjectiveMembershipWriter(this, loggerFactory);
+            var occurrenceDefinitionWriter = new OccurrenceDefinitionWriter(this, loggerFactory);
+            var occurrenceUsageWriter = new OccurrenceUsageWriter(this, loggerFactory);
+            var operatorExpressionWriter = new OperatorExpressionWriter(this, loggerFactory);
+            var owningMembershipWriter = new OwningMembershipWriter(this, loggerFactory);
+            var packageWriter = new PackageWriter(this, loggerFactory);
+            var parameterMembershipWriter = new ParameterMembershipWriter(this, loggerFactory);
+            var partDefinitionWriter = new PartDefinitionWriter(this, loggerFactory);
+            var partUsageWriter = new PartUsageWriter(this, loggerFactory);
+            var payloadFeatureWriter = new PayloadFeatureWriter(this, loggerFactory);
+            var performActionUsageWriter = new PerformActionUsageWriter(this, loggerFactory);
+            var portConjugationWriter = new PortConjugationWriter(this, loggerFactory);
+            var portDefinitionWriter = new PortDefinitionWriter(this, loggerFactory);
+            var portUsageWriter = new PortUsageWriter(this, loggerFactory);
+            var predicateWriter = new PredicateWriter(this, loggerFactory);
+            var redefinitionWriter = new RedefinitionWriter(this, loggerFactory);
+            var referenceSubsettingWriter = new ReferenceSubsettingWriter(this, loggerFactory);
+            var referenceUsageWriter = new ReferenceUsageWriter(this, loggerFactory);
+            var renderingDefinitionWriter = new RenderingDefinitionWriter(this, loggerFactory);
+            var renderingUsageWriter = new RenderingUsageWriter(this, loggerFactory);
+            var requirementConstraintMembershipWriter = new RequirementConstraintMembershipWriter(this, loggerFactory);
+            var requirementDefinitionWriter = new RequirementDefinitionWriter(this, loggerFactory);
+            var requirementUsageWriter = new RequirementUsageWriter(this, loggerFactory);
+            var requirementVerificationMembershipWriter = new RequirementVerificationMembershipWriter(this, loggerFactory);
+            var resultExpressionMembershipWriter = new ResultExpressionMembershipWriter(this, loggerFactory);
+            var returnParameterMembershipWriter = new ReturnParameterMembershipWriter(this, loggerFactory);
+            var satisfyRequirementUsageWriter = new SatisfyRequirementUsageWriter(this, loggerFactory);
+            var selectExpressionWriter = new SelectExpressionWriter(this, loggerFactory);
+            var sendActionUsageWriter = new SendActionUsageWriter(this, loggerFactory);
+            var specializationWriter = new SpecializationWriter(this, loggerFactory);
+            var stakeholderMembershipWriter = new StakeholderMembershipWriter(this, loggerFactory);
+            var stateDefinitionWriter = new StateDefinitionWriter(this, loggerFactory);
+            var stateSubactionMembershipWriter = new StateSubactionMembershipWriter(this, loggerFactory);
+            var stateUsageWriter = new StateUsageWriter(this, loggerFactory);
+            var stepWriter = new StepWriter(this, loggerFactory);
+            var structureWriter = new StructureWriter(this, loggerFactory);
+            var subclassificationWriter = new SubclassificationWriter(this, loggerFactory);
+            var subjectMembershipWriter = new SubjectMembershipWriter(this, loggerFactory);
+            var subsettingWriter = new SubsettingWriter(this, loggerFactory);
+            var successionWriter = new SuccessionWriter(this, loggerFactory);
+            var successionAsUsageWriter = new SuccessionAsUsageWriter(this, loggerFactory);
+            var successionFlowWriter = new SuccessionFlowWriter(this, loggerFactory);
+            var successionFlowUsageWriter = new SuccessionFlowUsageWriter(this, loggerFactory);
+            var terminateActionUsageWriter = new TerminateActionUsageWriter(this, loggerFactory);
+            var textualRepresentationWriter = new TextualRepresentationWriter(this, loggerFactory);
+            var transitionFeatureMembershipWriter = new TransitionFeatureMembershipWriter(this, loggerFactory);
+            var transitionUsageWriter = new TransitionUsageWriter(this, loggerFactory);
+            var triggerInvocationExpressionWriter = new TriggerInvocationExpressionWriter(this, loggerFactory);
+            var typeWriter = new TypeWriter(this, loggerFactory);
+            var typeFeaturingWriter = new TypeFeaturingWriter(this, loggerFactory);
+            var unioningWriter = new UnioningWriter(this, loggerFactory);
+            var usageWriter = new UsageWriter(this, loggerFactory);
+            var useCaseDefinitionWriter = new UseCaseDefinitionWriter(this, loggerFactory);
+            var useCaseUsageWriter = new UseCaseUsageWriter(this, loggerFactory);
+            var variantMembershipWriter = new VariantMembershipWriter(this, loggerFactory);
+            var verificationCaseDefinitionWriter = new VerificationCaseDefinitionWriter(this, loggerFactory);
+            var verificationCaseUsageWriter = new VerificationCaseUsageWriter(this, loggerFactory);
+            var viewDefinitionWriter = new ViewDefinitionWriter(this, loggerFactory);
+            var viewpointDefinitionWriter = new ViewpointDefinitionWriter(this, loggerFactory);
+            var viewpointUsageWriter = new ViewpointUsageWriter(this, loggerFactory);
+            var viewRenderingMembershipWriter = new ViewRenderingMembershipWriter(this, loggerFactory);
+            var viewUsageWriter = new ViewUsageWriter(this, loggerFactory);
+            var whileLoopActionUsageWriter = new WhileLoopActionUsageWriter(this, loggerFactory);
 
             this.writerCache = new Dictionary<string, Action<XmlWriter, IData, string, XmiWriterOptions, IXmiElementOriginMap, Uri>>
             {
                 ["AcceptActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AcceptActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, writerOptions, originMap, uri);
+                    acceptActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ActionDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ActionDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, writerOptions, originMap, uri);
+                    actionDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, writerOptions, originMap, uri);
+                    actionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ActorMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ActorMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, writerOptions, originMap, uri);
+                    actorMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AllocationDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AllocationDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, writerOptions, originMap, uri);
+                    allocationDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AllocationUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AllocationUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, writerOptions, originMap, uri);
+                    allocationUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AnalysisCaseDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AnalysisCaseDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, writerOptions, originMap, uri);
+                    analysisCaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AnalysisCaseUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AnalysisCaseUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, writerOptions, originMap, uri);
+                    analysisCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AnnotatingElement"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AnnotatingElementWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, writerOptions, originMap, uri);
+                    annotatingElementWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Annotation"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AnnotationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, writerOptions, originMap, uri);
+                    annotationWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AssertConstraintUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AssertConstraintUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, writerOptions, originMap, uri);
+                    assertConstraintUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AssignmentActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AssignmentActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, writerOptions, originMap, uri);
+                    assignmentActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Association"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AssociationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, writerOptions, originMap, uri);
+                    associationWriter.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AssociationStructure"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AssociationStructureWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, writerOptions, originMap, uri);
+                    associationStructureWriter.Write(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AttributeDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AttributeDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, writerOptions, originMap, uri);
+                    attributeDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AttributeUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AttributeUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, writerOptions, originMap, uri);
+                    attributeUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Behavior"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new BehaviorWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, writerOptions, originMap, uri);
+                    behaviorWriter.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, writerOptions, originMap, uri);
                 },
                 ["BindingConnector"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new BindingConnectorWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, writerOptions, originMap, uri);
+                    bindingConnectorWriter.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, writerOptions, originMap, uri);
                 },
                 ["BindingConnectorAsUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new BindingConnectorAsUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, writerOptions, originMap, uri);
+                    bindingConnectorAsUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["BooleanExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new BooleanExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, writerOptions, originMap, uri);
+                    booleanExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CalculationDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CalculationDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, writerOptions, originMap, uri);
+                    calculationDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CalculationUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CalculationUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, writerOptions, originMap, uri);
+                    calculationUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CaseDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CaseDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, writerOptions, originMap, uri);
+                    caseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CaseUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CaseUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, writerOptions, originMap, uri);
+                    caseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Class"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ClassWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, writerOptions, originMap, uri);
+                    classWriter.Write(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Classifier"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ClassifierWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, writerOptions, originMap, uri);
+                    classifierWriter.Write(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CollectExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CollectExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, writerOptions, originMap, uri);
+                    collectExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Comment"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CommentWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, writerOptions, originMap, uri);
+                    commentWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConcernDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConcernDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, writerOptions, originMap, uri);
+                    concernDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConcernUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConcernUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, writerOptions, originMap, uri);
+                    concernUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConjugatedPortDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConjugatedPortDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, writerOptions, originMap, uri);
+                    conjugatedPortDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConjugatedPortTyping"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConjugatedPortTypingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, writerOptions, originMap, uri);
+                    conjugatedPortTypingWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Conjugation"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConjugationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, writerOptions, originMap, uri);
+                    conjugationWriter.Write(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConnectionDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConnectionDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, writerOptions, originMap, uri);
+                    connectionDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConnectionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConnectionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, writerOptions, originMap, uri);
+                    connectionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Connector"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConnectorWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, writerOptions, originMap, uri);
+                    connectorWriter.Write(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConstraintDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConstraintDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, writerOptions, originMap, uri);
+                    constraintDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConstraintUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConstraintUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, writerOptions, originMap, uri);
+                    constraintUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConstructorExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConstructorExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, writerOptions, originMap, uri);
+                    constructorExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CrossSubsetting"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CrossSubsettingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, writerOptions, originMap, uri);
+                    crossSubsettingWriter.Write(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, writerOptions, originMap, uri);
                 },
                 ["DataType"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DataTypeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, writerOptions, originMap, uri);
+                    dataTypeWriter.Write(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, writerOptions, originMap, uri);
                 },
                 ["DecisionNode"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DecisionNodeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, writerOptions, originMap, uri);
+                    decisionNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Definition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, writerOptions, originMap, uri);
+                    definitionWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Dependency"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DependencyWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, writerOptions, originMap, uri);
+                    dependencyWriter.Write(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Differencing"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DifferencingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, writerOptions, originMap, uri);
+                    differencingWriter.Write(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Disjoining"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DisjoiningWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, writerOptions, originMap, uri);
+                    disjoiningWriter.Write(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Documentation"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DocumentationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, writerOptions, originMap, uri);
+                    documentationWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ElementFilterMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ElementFilterMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, writerOptions, originMap, uri);
+                    elementFilterMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["EndFeatureMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new EndFeatureMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, writerOptions, originMap, uri);
+                    endFeatureMembershipWriter.Write(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["EnumerationDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new EnumerationDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, writerOptions, originMap, uri);
+                    enumerationDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["EnumerationUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new EnumerationUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, writerOptions, originMap, uri);
+                    enumerationUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["EventOccurrenceUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new EventOccurrenceUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
+                    eventOccurrenceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ExhibitStateUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ExhibitStateUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, writerOptions, originMap, uri);
+                    exhibitStateUsageWriter.Write(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Expression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, writerOptions, originMap, uri);
+                    expressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Feature"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, writerOptions, originMap, uri);
+                    featureWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureChainExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureChainExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, writerOptions, originMap, uri);
+                    featureChainExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureChaining"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureChainingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, writerOptions, originMap, uri);
+                    featureChainingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureInverting"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureInvertingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, writerOptions, originMap, uri);
+                    featureInvertingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, writerOptions, originMap, uri);
+                    featureMembershipWriter.Write(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureReferenceExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureReferenceExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, writerOptions, originMap, uri);
+                    featureReferenceExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureTyping"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureTypingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, writerOptions, originMap, uri);
+                    featureTypingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureValue"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureValueWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, writerOptions, originMap, uri);
+                    featureValueWriter.Write(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Flow"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FlowWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, writerOptions, originMap, uri);
+                    flowWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FlowDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FlowDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, writerOptions, originMap, uri);
+                    flowDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FlowEnd"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FlowEndWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, writerOptions, originMap, uri);
+                    flowEndWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FlowUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FlowUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, writerOptions, originMap, uri);
+                    flowUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ForkNode"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ForkNodeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, writerOptions, originMap, uri);
+                    forkNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ForLoopActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ForLoopActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, writerOptions, originMap, uri);
+                    forLoopActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FramedConcernMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FramedConcernMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, writerOptions, originMap, uri);
+                    framedConcernMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Function"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FunctionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, writerOptions, originMap, uri);
+                    functionWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, writerOptions, originMap, uri);
                 },
                 ["IfActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new IfActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, writerOptions, originMap, uri);
+                    ifActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["IncludeUseCaseUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new IncludeUseCaseUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, writerOptions, originMap, uri);
+                    includeUseCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["IndexExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new IndexExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, writerOptions, originMap, uri);
+                    indexExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Interaction"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new InteractionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, writerOptions, originMap, uri);
+                    interactionWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, writerOptions, originMap, uri);
                 },
                 ["InterfaceDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new InterfaceDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, writerOptions, originMap, uri);
+                    interfaceDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["InterfaceUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new InterfaceUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, writerOptions, originMap, uri);
+                    interfaceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Intersecting"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new IntersectingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, writerOptions, originMap, uri);
+                    intersectingWriter.Write(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Invariant"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new InvariantWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, writerOptions, originMap, uri);
+                    invariantWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, writerOptions, originMap, uri);
                 },
                 ["InvocationExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new InvocationExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, writerOptions, originMap, uri);
+                    invocationExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ItemDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ItemDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, writerOptions, originMap, uri);
+                    itemDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ItemUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ItemUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, writerOptions, originMap, uri);
+                    itemUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["JoinNode"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new JoinNodeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, writerOptions, originMap, uri);
+                    joinNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LibraryPackage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LibraryPackageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, writerOptions, originMap, uri);
+                    libraryPackageWriter.Write(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralBoolean"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralBooleanWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, writerOptions, originMap, uri);
+                    literalBooleanWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, writerOptions, originMap, uri);
+                    literalExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralInfinity"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralInfinityWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, writerOptions, originMap, uri);
+                    literalInfinityWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralInteger"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralIntegerWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, writerOptions, originMap, uri);
+                    literalIntegerWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralRational"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralRationalWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, writerOptions, originMap, uri);
+                    literalRationalWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralString"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralStringWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, writerOptions, originMap, uri);
+                    literalStringWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Membership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, writerOptions, originMap, uri);
+                    membershipWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MembershipExpose"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MembershipExposeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, writerOptions, originMap, uri);
+                    membershipExposeWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MembershipImport"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MembershipImportWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, writerOptions, originMap, uri);
+                    membershipImportWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MergeNode"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MergeNodeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, writerOptions, originMap, uri);
+                    mergeNodeWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Metaclass"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MetaclassWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, writerOptions, originMap, uri);
+                    metaclassWriter.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MetadataAccessExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MetadataAccessExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, writerOptions, originMap, uri);
+                    metadataAccessExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MetadataDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MetadataDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, writerOptions, originMap, uri);
+                    metadataDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MetadataFeature"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MetadataFeatureWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, writerOptions, originMap, uri);
+                    metadataFeatureWriter.Write(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MetadataUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MetadataUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, writerOptions, originMap, uri);
+                    metadataUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Multiplicity"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MultiplicityWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, writerOptions, originMap, uri);
+                    multiplicityWriter.Write(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MultiplicityRange"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MultiplicityRangeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, writerOptions, originMap, uri);
+                    multiplicityRangeWriter.Write(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Namespace"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new NamespaceWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, writerOptions, originMap, uri);
+                    namespaceWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, writerOptions, originMap, uri);
                 },
                 ["NamespaceExpose"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new NamespaceExposeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, writerOptions, originMap, uri);
+                    namespaceExposeWriter.Write(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, writerOptions, originMap, uri);
                 },
                 ["NamespaceImport"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new NamespaceImportWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, writerOptions, originMap, uri);
+                    namespaceImportWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, writerOptions, originMap, uri);
                 },
                 ["NullExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new NullExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, writerOptions, originMap, uri);
+                    nullExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ObjectiveMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ObjectiveMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, writerOptions, originMap, uri);
+                    objectiveMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["OccurrenceDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new OccurrenceDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, writerOptions, originMap, uri);
+                    occurrenceDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["OccurrenceUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new OccurrenceUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
+                    occurrenceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["OperatorExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new OperatorExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, writerOptions, originMap, uri);
+                    operatorExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["OwningMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new OwningMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, writerOptions, originMap, uri);
+                    owningMembershipWriter.Write(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Package"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PackageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, writerOptions, originMap, uri);
+                    packageWriter.Write(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ParameterMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ParameterMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, writerOptions, originMap, uri);
+                    parameterMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PartDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PartDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, writerOptions, originMap, uri);
+                    partDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PartUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PartUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, writerOptions, originMap, uri);
+                    partUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PayloadFeature"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PayloadFeatureWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, writerOptions, originMap, uri);
+                    payloadFeatureWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PerformActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PerformActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, writerOptions, originMap, uri);
+                    performActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PortConjugation"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PortConjugationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, writerOptions, originMap, uri);
+                    portConjugationWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PortDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PortDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, writerOptions, originMap, uri);
+                    portDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PortUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PortUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, writerOptions, originMap, uri);
+                    portUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Predicate"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PredicateWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, writerOptions, originMap, uri);
+                    predicateWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Redefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RedefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, writerOptions, originMap, uri);
+                    redefinitionWriter.Write(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ReferenceSubsetting"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ReferenceSubsettingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, writerOptions, originMap, uri);
+                    referenceSubsettingWriter.Write(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ReferenceUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ReferenceUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, writerOptions, originMap, uri);
+                    referenceUsageWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RenderingDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RenderingDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, writerOptions, originMap, uri);
+                    renderingDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RenderingUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RenderingUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, writerOptions, originMap, uri);
+                    renderingUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RequirementConstraintMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RequirementConstraintMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, writerOptions, originMap, uri);
+                    requirementConstraintMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RequirementDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RequirementDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, writerOptions, originMap, uri);
+                    requirementDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RequirementUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RequirementUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, writerOptions, originMap, uri);
+                    requirementUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RequirementVerificationMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RequirementVerificationMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, writerOptions, originMap, uri);
+                    requirementVerificationMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ResultExpressionMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ResultExpressionMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, writerOptions, originMap, uri);
+                    resultExpressionMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ReturnParameterMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ReturnParameterMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, writerOptions, originMap, uri);
+                    returnParameterMembershipWriter.Write(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SatisfyRequirementUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SatisfyRequirementUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, writerOptions, originMap, uri);
+                    satisfyRequirementUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SelectExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SelectExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, writerOptions, originMap, uri);
+                    selectExpressionWriter.Write(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SendActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SendActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, writerOptions, originMap, uri);
+                    sendActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Specialization"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SpecializationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, writerOptions, originMap, uri);
+                    specializationWriter.Write(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, writerOptions, originMap, uri);
                 },
                 ["StakeholderMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StakeholderMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, writerOptions, originMap, uri);
+                    stakeholderMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["StateDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StateDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, writerOptions, originMap, uri);
+                    stateDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["StateSubactionMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StateSubactionMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, writerOptions, originMap, uri);
+                    stateSubactionMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["StateUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StateUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, writerOptions, originMap, uri);
+                    stateUsageWriter.Write(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Step"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StepWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, writerOptions, originMap, uri);
+                    stepWriter.Write(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Structure"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StructureWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, writerOptions, originMap, uri);
+                    structureWriter.Write(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Subclassification"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SubclassificationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, writerOptions, originMap, uri);
+                    subclassificationWriter.Write(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SubjectMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SubjectMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, writerOptions, originMap, uri);
+                    subjectMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Subsetting"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SubsettingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, writerOptions, originMap, uri);
+                    subsettingWriter.Write(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Succession"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SuccessionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, writerOptions, originMap, uri);
+                    successionWriter.Write(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SuccessionAsUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SuccessionAsUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, writerOptions, originMap, uri);
+                    successionAsUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SuccessionFlow"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SuccessionFlowWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, writerOptions, originMap, uri);
+                    successionFlowWriter.Write(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SuccessionFlowUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SuccessionFlowUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, writerOptions, originMap, uri);
+                    successionFlowUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TerminateActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TerminateActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, writerOptions, originMap, uri);
+                    terminateActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TextualRepresentation"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TextualRepresentationWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, writerOptions, originMap, uri);
+                    textualRepresentationWriter.Write(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TransitionFeatureMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TransitionFeatureMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, writerOptions, originMap, uri);
+                    transitionFeatureMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TransitionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TransitionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, writerOptions, originMap, uri);
+                    transitionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TriggerInvocationExpression"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TriggerInvocationExpressionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, writerOptions, originMap, uri);
+                    triggerInvocationExpressionWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Type"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TypeWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, writerOptions, originMap, uri);
+                    typeWriter.Write(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TypeFeaturing"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TypeFeaturingWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, writerOptions, originMap, uri);
+                    typeFeaturingWriter.Write(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Unioning"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new UnioningWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, writerOptions, originMap, uri);
+                    unioningWriter.Write(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Usage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new UsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, writerOptions, originMap, uri);
+                    usageWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["UseCaseDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new UseCaseDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, writerOptions, originMap, uri);
+                    useCaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["UseCaseUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new UseCaseUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, writerOptions, originMap, uri);
+                    useCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["VariantMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new VariantMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, writerOptions, originMap, uri);
+                    variantMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["VerificationCaseDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new VerificationCaseDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, writerOptions, originMap, uri);
+                    verificationCaseDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["VerificationCaseUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new VerificationCaseUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, writerOptions, originMap, uri);
+                    verificationCaseUsageWriter.Write(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ViewDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ViewDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, writerOptions, originMap, uri);
+                    viewDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ViewpointDefinition"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ViewpointDefinitionWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, writerOptions, originMap, uri);
+                    viewpointDefinitionWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ViewpointUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ViewpointUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, writerOptions, originMap, uri);
+                    viewpointUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ViewRenderingMembership"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ViewRenderingMembershipWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, writerOptions, originMap, uri);
+                    viewRenderingMembershipWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ViewUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ViewUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, writerOptions, originMap, uri);
+                    viewUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["WhileLoopActionUsage"] = (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new WhileLoopActionUsageWriter(this, this.loggerFactory);
-                    writer.Write(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, writerOptions, originMap, uri);
+                    whileLoopActionUsageWriter.Write(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
             };
 
@@ -906,838 +900,671 @@ public XmiDataWriterFacade(ILoggerFactory loggerFactory)
             {
                 ["AcceptActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AcceptActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, writerOptions, originMap, uri);
+                    await acceptActionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IAcceptActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ActionDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ActionDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, writerOptions, originMap, uri);
+                    await actionDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IActionDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, writerOptions, originMap, uri);
+                    await actionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ActorMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ActorMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, writerOptions, originMap, uri);
+                    await actorMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IActorMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AllocationDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AllocationDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, writerOptions, originMap, uri);
+                    await allocationDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AllocationUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AllocationUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, writerOptions, originMap, uri);
+                    await allocationUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Allocations.IAllocationUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AnalysisCaseDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AnalysisCaseDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, writerOptions, originMap, uri);
+                    await analysisCaseDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AnalysisCaseUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AnalysisCaseUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, writerOptions, originMap, uri);
+                    await analysisCaseUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.AnalysisCases.IAnalysisCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AnnotatingElement"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AnnotatingElementWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, writerOptions, originMap, uri);
+                    await annotatingElementWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IAnnotatingElement)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Annotation"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AnnotationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, writerOptions, originMap, uri);
+                    await annotationWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IAnnotation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AssertConstraintUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AssertConstraintUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, writerOptions, originMap, uri);
+                    await assertConstraintUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IAssertConstraintUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AssignmentActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AssignmentActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, writerOptions, originMap, uri);
+                    await assignmentActionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IAssignmentActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Association"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AssociationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, writerOptions, originMap, uri);
+                    await associationWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Associations.IAssociation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AssociationStructure"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AssociationStructureWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, writerOptions, originMap, uri);
+                    await associationStructureWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Associations.IAssociationStructure)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AttributeDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AttributeDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, writerOptions, originMap, uri);
+                    await attributeDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["AttributeUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new AttributeUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, writerOptions, originMap, uri);
+                    await attributeUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Attributes.IAttributeUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Behavior"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new BehaviorWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, writerOptions, originMap, uri);
+                    await behaviorWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IBehavior)data, elementName, writerOptions, originMap, uri);
                 },
                 ["BindingConnector"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new BindingConnectorWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, writerOptions, originMap, uri);
+                    await bindingConnectorWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.IBindingConnector)data, elementName, writerOptions, originMap, uri);
                 },
                 ["BindingConnectorAsUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new BindingConnectorAsUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, writerOptions, originMap, uri);
+                    await bindingConnectorAsUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IBindingConnectorAsUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["BooleanExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new BooleanExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, writerOptions, originMap, uri);
+                    await booleanExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IBooleanExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CalculationDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CalculationDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, writerOptions, originMap, uri);
+                    await calculationDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CalculationUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CalculationUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, writerOptions, originMap, uri);
+                    await calculationUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Calculations.ICalculationUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CaseDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CaseDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, writerOptions, originMap, uri);
+                    await caseDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.ICaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CaseUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CaseUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, writerOptions, originMap, uri);
+                    await caseUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.ICaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Class"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ClassWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, writerOptions, originMap, uri);
+                    await classWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Classes.IClass)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Classifier"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ClassifierWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, writerOptions, originMap, uri);
+                    await classifierWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Classifiers.IClassifier)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CollectExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CollectExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, writerOptions, originMap, uri);
+                    await collectExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ICollectExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Comment"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CommentWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, writerOptions, originMap, uri);
+                    await commentWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IComment)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConcernDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConcernDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, writerOptions, originMap, uri);
+                    await concernDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IConcernDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConcernUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConcernUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, writerOptions, originMap, uri);
+                    await concernUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IConcernUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConjugatedPortDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConjugatedPortDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, writerOptions, originMap, uri);
+                    await conjugatedPortDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConjugatedPortTyping"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConjugatedPortTypingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, writerOptions, originMap, uri);
+                    await conjugatedPortTypingWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IConjugatedPortTyping)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Conjugation"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConjugationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, writerOptions, originMap, uri);
+                    await conjugationWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IConjugation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConnectionDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConnectionDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, writerOptions, originMap, uri);
+                    await connectionDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IConnectionDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConnectionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConnectionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, writerOptions, originMap, uri);
+                    await connectionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.IConnectionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Connector"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConnectorWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, writerOptions, originMap, uri);
+                    await connectorWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.IConnector)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConstraintDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConstraintDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, writerOptions, originMap, uri);
+                    await constraintDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConstraintUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConstraintUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, writerOptions, originMap, uri);
+                    await constraintUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Constraints.IConstraintUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ConstructorExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ConstructorExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, writerOptions, originMap, uri);
+                    await constructorExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IConstructorExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["CrossSubsetting"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new CrossSubsettingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, writerOptions, originMap, uri);
+                    await crossSubsettingWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ICrossSubsetting)data, elementName, writerOptions, originMap, uri);
                 },
                 ["DataType"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DataTypeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, writerOptions, originMap, uri);
+                    await dataTypeWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.DataTypes.IDataType)data, elementName, writerOptions, originMap, uri);
                 },
                 ["DecisionNode"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DecisionNodeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, writerOptions, originMap, uri);
+                    await decisionNodeWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IDecisionNode)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Definition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, writerOptions, originMap, uri);
+                    await definitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Dependency"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DependencyWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, writerOptions, originMap, uri);
+                    await dependencyWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Dependencies.IDependency)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Differencing"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DifferencingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, writerOptions, originMap, uri);
+                    await differencingWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IDifferencing)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Disjoining"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DisjoiningWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, writerOptions, originMap, uri);
+                    await disjoiningWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IDisjoining)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Documentation"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new DocumentationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, writerOptions, originMap, uri);
+                    await documentationWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.IDocumentation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ElementFilterMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ElementFilterMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, writerOptions, originMap, uri);
+                    await elementFilterMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.IElementFilterMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["EndFeatureMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new EndFeatureMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, writerOptions, originMap, uri);
+                    await endFeatureMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IEndFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["EnumerationDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new EnumerationDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, writerOptions, originMap, uri);
+                    await enumerationDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["EnumerationUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new EnumerationUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, writerOptions, originMap, uri);
+                    await enumerationUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Enumerations.IEnumerationUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["EventOccurrenceUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new EventOccurrenceUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
+                    await eventOccurrenceUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IEventOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ExhibitStateUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ExhibitStateUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, writerOptions, originMap, uri);
+                    await exhibitStateUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IExhibitStateUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Expression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, writerOptions, originMap, uri);
+                    await expressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Feature"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, writerOptions, originMap, uri);
+                    await featureWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeature)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureChainExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureChainExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, writerOptions, originMap, uri);
+                    await featureChainExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureChainExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureChaining"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureChainingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, writerOptions, originMap, uri);
+                    await featureChainingWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureChaining)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureInverting"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureInvertingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, writerOptions, originMap, uri);
+                    await featureInvertingWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureInverting)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, writerOptions, originMap, uri);
+                    await featureMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureReferenceExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureReferenceExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, writerOptions, originMap, uri);
+                    await featureReferenceExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IFeatureReferenceExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureTyping"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureTypingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, writerOptions, originMap, uri);
+                    await featureTypingWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IFeatureTyping)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FeatureValue"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FeatureValueWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, writerOptions, originMap, uri);
+                    await featureValueWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.FeatureValues.IFeatureValue)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Flow"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FlowWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, writerOptions, originMap, uri);
+                    await flowWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IFlow)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FlowDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FlowDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, writerOptions, originMap, uri);
+                    await flowDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.IFlowDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FlowEnd"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FlowEndWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, writerOptions, originMap, uri);
+                    await flowEndWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IFlowEnd)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FlowUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FlowUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, writerOptions, originMap, uri);
+                    await flowUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.IFlowUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ForkNode"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ForkNodeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, writerOptions, originMap, uri);
+                    await forkNodeWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IForkNode)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ForLoopActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ForLoopActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, writerOptions, originMap, uri);
+                    await forLoopActionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IForLoopActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["FramedConcernMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FramedConcernMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, writerOptions, originMap, uri);
+                    await framedConcernMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IFramedConcernMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Function"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new FunctionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, writerOptions, originMap, uri);
+                    await functionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IFunction)data, elementName, writerOptions, originMap, uri);
                 },
                 ["IfActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new IfActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, writerOptions, originMap, uri);
+                    await ifActionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IIfActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["IncludeUseCaseUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new IncludeUseCaseUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, writerOptions, originMap, uri);
+                    await includeUseCaseUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IIncludeUseCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["IndexExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new IndexExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, writerOptions, originMap, uri);
+                    await indexExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IIndexExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Interaction"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new InteractionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, writerOptions, originMap, uri);
+                    await interactionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IInteraction)data, elementName, writerOptions, originMap, uri);
                 },
                 ["InterfaceDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new InterfaceDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, writerOptions, originMap, uri);
+                    await interfaceDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["InterfaceUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new InterfaceUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, writerOptions, originMap, uri);
+                    await interfaceUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Interfaces.IInterfaceUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Intersecting"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new IntersectingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, writerOptions, originMap, uri);
+                    await intersectingWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IIntersecting)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Invariant"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new InvariantWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, writerOptions, originMap, uri);
+                    await invariantWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IInvariant)data, elementName, writerOptions, originMap, uri);
                 },
                 ["InvocationExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new InvocationExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, writerOptions, originMap, uri);
+                    await invocationExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IInvocationExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ItemDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ItemDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, writerOptions, originMap, uri);
+                    await itemDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Items.IItemDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ItemUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ItemUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, writerOptions, originMap, uri);
+                    await itemUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Items.IItemUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["JoinNode"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new JoinNodeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, writerOptions, originMap, uri);
+                    await joinNodeWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IJoinNode)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LibraryPackage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LibraryPackageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, writerOptions, originMap, uri);
+                    await libraryPackageWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.ILibraryPackage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralBoolean"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralBooleanWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, writerOptions, originMap, uri);
+                    await literalBooleanWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralBoolean)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, writerOptions, originMap, uri);
+                    await literalExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralInfinity"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralInfinityWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, writerOptions, originMap, uri);
+                    await literalInfinityWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInfinity)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralInteger"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralIntegerWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, writerOptions, originMap, uri);
+                    await literalIntegerWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralInteger)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralRational"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralRationalWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, writerOptions, originMap, uri);
+                    await literalRationalWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralRational)data, elementName, writerOptions, originMap, uri);
                 },
                 ["LiteralString"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new LiteralStringWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, writerOptions, originMap, uri);
+                    await literalStringWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ILiteralString)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Membership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, writerOptions, originMap, uri);
+                    await membershipWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MembershipExpose"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MembershipExposeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, writerOptions, originMap, uri);
+                    await membershipExposeWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IMembershipExpose)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MembershipImport"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MembershipImportWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, writerOptions, originMap, uri);
+                    await membershipImportWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IMembershipImport)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MergeNode"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MergeNodeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, writerOptions, originMap, uri);
+                    await mergeNodeWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IMergeNode)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Metaclass"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MetaclassWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, writerOptions, originMap, uri);
+                    await metaclassWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Metadata.IMetaclass)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MetadataAccessExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MetadataAccessExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, writerOptions, originMap, uri);
+                    await metadataAccessExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IMetadataAccessExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MetadataDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MetadataDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, writerOptions, originMap, uri);
+                    await metadataDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MetadataFeature"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MetadataFeatureWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, writerOptions, originMap, uri);
+                    await metadataFeatureWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Metadata.IMetadataFeature)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MetadataUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MetadataUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, writerOptions, originMap, uri);
+                    await metadataUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Metadata.IMetadataUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Multiplicity"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MultiplicityWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, writerOptions, originMap, uri);
+                    await multiplicityWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IMultiplicity)data, elementName, writerOptions, originMap, uri);
                 },
                 ["MultiplicityRange"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new MultiplicityRangeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, writerOptions, originMap, uri);
+                    await multiplicityRangeWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Multiplicities.IMultiplicityRange)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Namespace"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new NamespaceWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, writerOptions, originMap, uri);
+                    await namespaceWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.INamespace)data, elementName, writerOptions, originMap, uri);
                 },
                 ["NamespaceExpose"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new NamespaceExposeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, writerOptions, originMap, uri);
+                    await namespaceExposeWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.INamespaceExpose)data, elementName, writerOptions, originMap, uri);
                 },
                 ["NamespaceImport"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new NamespaceImportWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, writerOptions, originMap, uri);
+                    await namespaceImportWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.INamespaceImport)data, elementName, writerOptions, originMap, uri);
                 },
                 ["NullExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new NullExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, writerOptions, originMap, uri);
+                    await nullExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.INullExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ObjectiveMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ObjectiveMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, writerOptions, originMap, uri);
+                    await objectiveMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Cases.IObjectiveMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["OccurrenceDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new OccurrenceDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, writerOptions, originMap, uri);
+                    await occurrenceDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["OccurrenceUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new OccurrenceUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
+                    await occurrenceUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Occurrences.IOccurrenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["OperatorExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new OperatorExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, writerOptions, originMap, uri);
+                    await operatorExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.IOperatorExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["OwningMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new OwningMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, writerOptions, originMap, uri);
+                    await owningMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Namespaces.IOwningMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Package"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PackageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, writerOptions, originMap, uri);
+                    await packageWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Packages.IPackage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ParameterMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ParameterMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, writerOptions, originMap, uri);
+                    await parameterMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IParameterMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PartDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PartDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, writerOptions, originMap, uri);
+                    await partDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Parts.IPartDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PartUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PartUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, writerOptions, originMap, uri);
+                    await partUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Parts.IPartUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PayloadFeature"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PayloadFeatureWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, writerOptions, originMap, uri);
+                    await payloadFeatureWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.IPayloadFeature)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PerformActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PerformActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, writerOptions, originMap, uri);
+                    await performActionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IPerformActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PortConjugation"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PortConjugationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, writerOptions, originMap, uri);
+                    await portConjugationWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortConjugation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PortDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PortDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, writerOptions, originMap, uri);
+                    await portDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["PortUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PortUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, writerOptions, originMap, uri);
+                    await portUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Ports.IPortUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Predicate"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new PredicateWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, writerOptions, originMap, uri);
+                    await predicateWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IPredicate)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Redefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RedefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, writerOptions, originMap, uri);
+                    await redefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IRedefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ReferenceSubsetting"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ReferenceSubsettingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, writerOptions, originMap, uri);
+                    await referenceSubsettingWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Features.IReferenceSubsetting)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ReferenceUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ReferenceUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, writerOptions, originMap, uri);
+                    await referenceUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IReferenceUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RenderingDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RenderingDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, writerOptions, originMap, uri);
+                    await renderingDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IRenderingDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RenderingUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RenderingUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, writerOptions, originMap, uri);
+                    await renderingUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IRenderingUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RequirementConstraintMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RequirementConstraintMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, writerOptions, originMap, uri);
+                    await requirementConstraintMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementConstraintMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RequirementDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RequirementDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, writerOptions, originMap, uri);
+                    await requirementDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RequirementUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RequirementUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, writerOptions, originMap, uri);
+                    await requirementUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IRequirementUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["RequirementVerificationMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new RequirementVerificationMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, writerOptions, originMap, uri);
+                    await requirementVerificationMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IRequirementVerificationMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ResultExpressionMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ResultExpressionMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, writerOptions, originMap, uri);
+                    await resultExpressionMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IResultExpressionMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ReturnParameterMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ReturnParameterMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, writerOptions, originMap, uri);
+                    await returnParameterMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Functions.IReturnParameterMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SatisfyRequirementUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SatisfyRequirementUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, writerOptions, originMap, uri);
+                    await satisfyRequirementUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.ISatisfyRequirementUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SelectExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SelectExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, writerOptions, originMap, uri);
+                    await selectExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Expressions.ISelectExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SendActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SendActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, writerOptions, originMap, uri);
+                    await sendActionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ISendActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Specialization"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SpecializationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, writerOptions, originMap, uri);
+                    await specializationWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Types.ISpecialization)data, elementName, writerOptions, originMap, uri);
                 },
                 ["StakeholderMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StakeholderMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, writerOptions, originMap, uri);
+                    await stakeholderMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.IStakeholderMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["StateDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StateDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, writerOptions, originMap, uri);
+                    await stateDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["StateSubactionMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StateSubactionMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, writerOptions, originMap, uri);
+                    await stateSubactionMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateSubactionMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["StateUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StateUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, writerOptions, originMap, uri);
+                    await stateUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.States.IStateUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Step"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StepWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, writerOptions, originMap, uri);
+                    await stepWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Behaviors.IStep)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Structure"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new StructureWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, writerOptions, originMap, uri);
+                    await structureWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Structures.IStructure)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Subclassification"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SubclassificationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, writerOptions, originMap, uri);
+                    await subclassificationWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Classifiers.ISubclassification)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SubjectMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SubjectMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, writerOptions, originMap, uri);
+                    await subjectMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Requirements.ISubjectMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Subsetting"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SubsettingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, writerOptions, originMap, uri);
+                    await subsettingWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ISubsetting)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Succession"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SuccessionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, writerOptions, originMap, uri);
+                    await successionWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Connectors.ISuccession)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SuccessionAsUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SuccessionAsUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, writerOptions, originMap, uri);
+                    await successionAsUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Connections.ISuccessionAsUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SuccessionFlow"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SuccessionFlowWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, writerOptions, originMap, uri);
+                    await successionFlowWriter.WriteAsync(xmlWriter, (Core.POCO.Kernel.Interactions.ISuccessionFlow)data, elementName, writerOptions, originMap, uri);
                 },
                 ["SuccessionFlowUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new SuccessionFlowUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, writerOptions, originMap, uri);
+                    await successionFlowUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Flows.ISuccessionFlowUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TerminateActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TerminateActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, writerOptions, originMap, uri);
+                    await terminateActionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ITerminateActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TextualRepresentation"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TextualRepresentationWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, writerOptions, originMap, uri);
+                    await textualRepresentationWriter.WriteAsync(xmlWriter, (Core.POCO.Root.Annotations.ITextualRepresentation)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TransitionFeatureMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TransitionFeatureMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, writerOptions, originMap, uri);
+                    await transitionFeatureMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.States.ITransitionFeatureMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TransitionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TransitionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, writerOptions, originMap, uri);
+                    await transitionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.States.ITransitionUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TriggerInvocationExpression"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TriggerInvocationExpressionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, writerOptions, originMap, uri);
+                    await triggerInvocationExpressionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.ITriggerInvocationExpression)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Type"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TypeWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, writerOptions, originMap, uri);
+                    await typeWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IType)data, elementName, writerOptions, originMap, uri);
                 },
                 ["TypeFeaturing"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new TypeFeaturingWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, writerOptions, originMap, uri);
+                    await typeFeaturingWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Features.ITypeFeaturing)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Unioning"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new UnioningWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, writerOptions, originMap, uri);
+                    await unioningWriter.WriteAsync(xmlWriter, (Core.POCO.Core.Types.IUnioning)data, elementName, writerOptions, originMap, uri);
                 },
                 ["Usage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new UsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, writerOptions, originMap, uri);
+                    await usageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["UseCaseDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new UseCaseDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, writerOptions, originMap, uri);
+                    await useCaseDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["UseCaseUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new UseCaseUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, writerOptions, originMap, uri);
+                    await useCaseUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.UseCases.IUseCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["VariantMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new VariantMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, writerOptions, originMap, uri);
+                    await variantMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.DefinitionAndUsage.IVariantMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["VerificationCaseDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new VerificationCaseDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, writerOptions, originMap, uri);
+                    await verificationCaseDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["VerificationCaseUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new VerificationCaseUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, writerOptions, originMap, uri);
+                    await verificationCaseUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.VerificationCases.IVerificationCaseUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ViewDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ViewDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, writerOptions, originMap, uri);
+                    await viewDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ViewpointDefinition"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ViewpointDefinitionWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, writerOptions, originMap, uri);
+                    await viewpointDefinitionWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewpointDefinition)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ViewpointUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ViewpointUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, writerOptions, originMap, uri);
+                    await viewpointUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewpointUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ViewRenderingMembership"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ViewRenderingMembershipWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, writerOptions, originMap, uri);
+                    await viewRenderingMembershipWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewRenderingMembership)data, elementName, writerOptions, originMap, uri);
                 },
                 ["ViewUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new ViewUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, writerOptions, originMap, uri);
+                    await viewUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Views.IViewUsage)data, elementName, writerOptions, originMap, uri);
                 },
                 ["WhileLoopActionUsage"] = async (xmlWriter, data, elementName, writerOptions, originMap, uri) =>
                 {
-                    var writer = new WhileLoopActionUsageWriter(this, this.loggerFactory);
-                    await writer.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, writerOptions, originMap, uri);
+                    await whileLoopActionUsageWriter.WriteAsync(xmlWriter, (Core.POCO.Systems.Actions.IWhileLoopActionUsage)data, elementName, writerOptions, originMap, uri);
                 },
             };
         }

From 17996518843a4bbdae0d4a68c231f2abd6fd26e0 Mon Sep 17 00:00:00 2001
From: samatstarion <s.gerene@stariongroup.eu>
Date: Sat, 21 Mar 2026 15:22:11 +0100
Subject: [PATCH 8/9] [Refactor] XmiReaders to use generated enum providers to
 parse enum values

---
 .../TransitionFeatureKindProvider.cs          |  42 ++
 .../VisibilityKindProvider.cs                 |  42 ++
 .../AutoGenReaders/AnnotatingElementReader.cs |  83 +++-
 .../Core/AutoGenReaders/AssociationReader.cs  | 193 ++++++++--
 .../Core/AutoGenReaders/DependencyReader.cs   | 213 +++++++++--
 .../EnumerationDefinitionReader.cs            | 137 ++++++-
 .../UML/Core/AutoGenReaders/FeatureReader.cs  | 285 ++++++++++++--
 .../AutoGenReaders/FeatureTypingReader.cs     | 213 +++++++++--
 .../UML/Core/AutoGenReaders/FlowReader.cs     | 359 +++++++++++++++---
 .../FramedConcernMembershipReader.cs          | 201 ++++++++--
 .../AutoGenReaders/LiteralIntegerReader.cs    | 303 +++++++++++++--
 .../AutoGenReaders/LiteralRationalReader.cs   | 303 +++++++++++++--
 .../Core/AutoGenReaders/MembershipReader.cs   | 207 ++++++++--
 .../AutoGenReaders/MultiplicityRangeReader.cs | 285 ++++++++++++--
 .../AutoGenReaders/OwningMembershipReader.cs  | 179 +++++++--
 .../ReferenceSubsettingReader.cs              | 185 +++++++--
 .../AutoGenReaders/RequirementUsageReader.cs  | 325 ++++++++++++++--
 .../AutoGenReaders/SelectExpressionReader.cs  | 285 ++++++++++++--
 .../AutoGenReaders/SubclassificationReader.cs | 213 +++++++++--
 .../TextualRepresentationReader.cs            |  83 +++-
 .../UML/Core/AutoGenReaders/UsageReader.cs    | 285 ++++++++++++--
 ...-reader-partial-for-attribute-template.hbs |   4 +-
 ...mi-reader-partial-for-element-template.hbs |   8 +-
 .../Uml/core-enumprovider-uml-template.hbs    |  32 ++
 .../Uml/core-xmi-reader-template.hbs          |   1 +
 .../VisibilityKindProviderTestFixture.cs      |  23 ++
 .../FeatureDirectionKindProvider.cs           |  42 ++
 .../PortionKindProvider.cs                    |  36 ++
 .../RequirementConstraintKindProvider.cs      |  36 ++
 .../StateSubactionKindProvider.cs             |  42 ++
 .../TransitionFeatureKindProvider.cs          |  42 ++
 .../TriggerKindProvider.cs                    |  42 ++
 .../VisibilityKindProvider.cs                 |  42 ++
 .../AutoGenReaders/AcceptActionUsageReader.cs |  25 +-
 .../AutoGenReaders/ActionDefinitionReader.cs  |   1 +
 .../AutoGenReaders/ActionUsageReader.cs       |  25 +-
 .../AutoGenReaders/ActorMembershipReader.cs   |  13 +-
 .../AllocationDefinitionReader.cs             |   1 +
 .../AutoGenReaders/AllocationUsageReader.cs   |  25 +-
 .../AnalysisCaseDefinitionReader.cs           |   1 +
 .../AutoGenReaders/AnalysisCaseUsageReader.cs |  25 +-
 .../AutoGenReaders/AnnotatingElementReader.cs |   1 +
 .../AutoGenReaders/AnnotationReader.cs        |   1 +
 .../AssertConstraintUsageReader.cs            |  25 +-
 .../AssignmentActionUsageReader.cs            |  25 +-
 .../AutoGenReaders/AssociationReader.cs       |   1 +
 .../AssociationStructureReader.cs             |   1 +
 .../AttributeDefinitionReader.cs              |   1 +
 .../AutoGenReaders/AttributeUsageReader.cs    |  13 +-
 .../Readers/AutoGenReaders/BehaviorReader.cs  |   1 +
 .../BindingConnectorAsUsageReader.cs          |  13 +-
 .../AutoGenReaders/BindingConnectorReader.cs  |  13 +-
 .../AutoGenReaders/BooleanExpressionReader.cs |  13 +-
 .../CalculationDefinitionReader.cs            |   1 +
 .../AutoGenReaders/CalculationUsageReader.cs  |  25 +-
 .../AutoGenReaders/CaseDefinitionReader.cs    |   1 +
 .../Readers/AutoGenReaders/CaseUsageReader.cs |  25 +-
 .../Readers/AutoGenReaders/ClassReader.cs     |   1 +
 .../AutoGenReaders/ClassifierReader.cs        |   1 +
 .../AutoGenReaders/CollectExpressionReader.cs |  13 +-
 .../Readers/AutoGenReaders/CommentReader.cs   |   1 +
 .../AutoGenReaders/ConcernDefinitionReader.cs |   1 +
 .../AutoGenReaders/ConcernUsageReader.cs      |  25 +-
 .../ConjugatedPortDefinitionReader.cs         |   1 +
 .../ConjugatedPortTypingReader.cs             |   1 +
 .../AutoGenReaders/ConjugationReader.cs       |   1 +
 .../ConnectionDefinitionReader.cs             |   1 +
 .../AutoGenReaders/ConnectionUsageReader.cs   |  25 +-
 .../Readers/AutoGenReaders/ConnectorReader.cs |  13 +-
 .../ConstraintDefinitionReader.cs             |   1 +
 .../AutoGenReaders/ConstraintUsageReader.cs   |  25 +-
 .../ConstructorExpressionReader.cs            |  13 +-
 .../AutoGenReaders/CrossSubsettingReader.cs   |   1 +
 .../Readers/AutoGenReaders/DataTypeReader.cs  |   1 +
 .../AutoGenReaders/DecisionNodeReader.cs      |  25 +-
 .../AutoGenReaders/DefinitionReader.cs        |   1 +
 .../AutoGenReaders/DependencyReader.cs        |   1 +
 .../AutoGenReaders/DifferencingReader.cs      |   1 +
 .../AutoGenReaders/DisjoiningReader.cs        |   1 +
 .../AutoGenReaders/DocumentationReader.cs     |   1 +
 .../ElementFilterMembershipReader.cs          |  13 +-
 .../EndFeatureMembershipReader.cs             |  13 +-
 .../EnumerationDefinitionReader.cs            |   1 +
 .../AutoGenReaders/EnumerationUsageReader.cs  |  13 +-
 .../EventOccurrenceUsageReader.cs             |  25 +-
 .../AutoGenReaders/ExhibitStateUsageReader.cs |  25 +-
 .../AutoGenReaders/ExpressionReader.cs        |  13 +-
 .../FeatureChainExpressionReader.cs           |  13 +-
 .../AutoGenReaders/FeatureChainingReader.cs   |   1 +
 .../AutoGenReaders/FeatureInvertingReader.cs  |   1 +
 .../AutoGenReaders/FeatureMembershipReader.cs |  13 +-
 .../Readers/AutoGenReaders/FeatureReader.cs   |  13 +-
 .../FeatureReferenceExpressionReader.cs       |  13 +-
 .../AutoGenReaders/FeatureTypingReader.cs     |   1 +
 .../AutoGenReaders/FeatureValueReader.cs      |  13 +-
 .../AutoGenReaders/FlowDefinitionReader.cs    |   1 +
 .../Readers/AutoGenReaders/FlowEndReader.cs   |  13 +-
 .../Readers/AutoGenReaders/FlowReader.cs      |  13 +-
 .../Readers/AutoGenReaders/FlowUsageReader.cs |  25 +-
 .../ForLoopActionUsageReader.cs               |  25 +-
 .../Readers/AutoGenReaders/ForkNodeReader.cs  |  25 +-
 .../FramedConcernMembershipReader.cs          |  25 +-
 .../Readers/AutoGenReaders/FunctionReader.cs  |   1 +
 .../AutoGenReaders/IfActionUsageReader.cs     |  25 +-
 .../IncludeUseCaseUsageReader.cs              |  25 +-
 .../AutoGenReaders/IndexExpressionReader.cs   |  13 +-
 .../AutoGenReaders/InteractionReader.cs       |   1 +
 .../InterfaceDefinitionReader.cs              |   1 +
 .../AutoGenReaders/InterfaceUsageReader.cs    |  25 +-
 .../AutoGenReaders/IntersectingReader.cs      |   1 +
 .../Readers/AutoGenReaders/InvariantReader.cs |  13 +-
 .../InvocationExpressionReader.cs             |  13 +-
 .../AutoGenReaders/ItemDefinitionReader.cs    |   1 +
 .../Readers/AutoGenReaders/ItemUsageReader.cs |  25 +-
 .../Readers/AutoGenReaders/JoinNodeReader.cs  |  25 +-
 .../AutoGenReaders/LibraryPackageReader.cs    |   1 +
 .../AutoGenReaders/LiteralBooleanReader.cs    |  13 +-
 .../AutoGenReaders/LiteralExpressionReader.cs |  13 +-
 .../AutoGenReaders/LiteralInfinityReader.cs   |  13 +-
 .../AutoGenReaders/LiteralIntegerReader.cs    |  13 +-
 .../AutoGenReaders/LiteralRationalReader.cs   |  13 +-
 .../AutoGenReaders/LiteralStringReader.cs     |  13 +-
 .../AutoGenReaders/MembershipExposeReader.cs  |  13 +-
 .../AutoGenReaders/MembershipImportReader.cs  |  13 +-
 .../AutoGenReaders/MembershipReader.cs        |  13 +-
 .../Readers/AutoGenReaders/MergeNodeReader.cs |  25 +-
 .../Readers/AutoGenReaders/MetaclassReader.cs |   1 +
 .../MetadataAccessExpressionReader.cs         |  13 +-
 .../MetadataDefinitionReader.cs               |   1 +
 .../AutoGenReaders/MetadataFeatureReader.cs   |  13 +-
 .../AutoGenReaders/MetadataUsageReader.cs     |  25 +-
 .../AutoGenReaders/MultiplicityRangeReader.cs |  13 +-
 .../AutoGenReaders/MultiplicityReader.cs      |  13 +-
 .../AutoGenReaders/NamespaceExposeReader.cs   |  13 +-
 .../AutoGenReaders/NamespaceImportReader.cs   |  13 +-
 .../Readers/AutoGenReaders/NamespaceReader.cs |   1 +
 .../AutoGenReaders/NullExpressionReader.cs    |  13 +-
 .../ObjectiveMembershipReader.cs              |  13 +-
 .../OccurrenceDefinitionReader.cs             |   1 +
 .../AutoGenReaders/OccurrenceUsageReader.cs   |  25 +-
 .../OperatorExpressionReader.cs               |  13 +-
 .../AutoGenReaders/OwningMembershipReader.cs  |  13 +-
 .../Readers/AutoGenReaders/PackageReader.cs   |   1 +
 .../ParameterMembershipReader.cs              |  13 +-
 .../AutoGenReaders/PartDefinitionReader.cs    |   1 +
 .../Readers/AutoGenReaders/PartUsageReader.cs |  25 +-
 .../AutoGenReaders/PayloadFeatureReader.cs    |  13 +-
 .../PerformActionUsageReader.cs               |  25 +-
 .../AutoGenReaders/PortConjugationReader.cs   |   1 +
 .../AutoGenReaders/PortDefinitionReader.cs    |   1 +
 .../Readers/AutoGenReaders/PortUsageReader.cs |  25 +-
 .../Readers/AutoGenReaders/PredicateReader.cs |   1 +
 .../AutoGenReaders/RedefinitionReader.cs      |   1 +
 .../ReferenceSubsettingReader.cs              |   1 +
 .../AutoGenReaders/ReferenceUsageReader.cs    |  13 +-
 .../RenderingDefinitionReader.cs              |   1 +
 .../AutoGenReaders/RenderingUsageReader.cs    |  25 +-
 .../RequirementConstraintMembershipReader.cs  |  25 +-
 .../RequirementDefinitionReader.cs            |   1 +
 .../AutoGenReaders/RequirementUsageReader.cs  |  25 +-
 ...RequirementVerificationMembershipReader.cs |  25 +-
 .../ResultExpressionMembershipReader.cs       |  13 +-
 .../ReturnParameterMembershipReader.cs        |  13 +-
 .../SatisfyRequirementUsageReader.cs          |  25 +-
 .../AutoGenReaders/SelectExpressionReader.cs  |  13 +-
 .../AutoGenReaders/SendActionUsageReader.cs   |  25 +-
 .../AutoGenReaders/SpecializationReader.cs    |   1 +
 .../StakeholderMembershipReader.cs            |  13 +-
 .../AutoGenReaders/StateDefinitionReader.cs   |   1 +
 .../StateSubactionMembershipReader.cs         |  25 +-
 .../AutoGenReaders/StateUsageReader.cs        |  25 +-
 .../Readers/AutoGenReaders/StepReader.cs      |  13 +-
 .../Readers/AutoGenReaders/StructureReader.cs |   1 +
 .../AutoGenReaders/SubclassificationReader.cs |   1 +
 .../AutoGenReaders/SubjectMembershipReader.cs |  13 +-
 .../AutoGenReaders/SubsettingReader.cs        |   1 +
 .../AutoGenReaders/SuccessionAsUsageReader.cs |  13 +-
 .../AutoGenReaders/SuccessionFlowReader.cs    |  13 +-
 .../SuccessionFlowUsageReader.cs              |  25 +-
 .../AutoGenReaders/SuccessionReader.cs        |  13 +-
 .../TerminateActionUsageReader.cs             |  25 +-
 .../TextualRepresentationReader.cs            |   1 +
 .../TransitionFeatureMembershipReader.cs      |  25 +-
 .../AutoGenReaders/TransitionUsageReader.cs   |  25 +-
 .../TriggerInvocationExpressionReader.cs      |  25 +-
 .../AutoGenReaders/TypeFeaturingReader.cs     |   1 +
 .../Readers/AutoGenReaders/TypeReader.cs      |   1 +
 .../Readers/AutoGenReaders/UnioningReader.cs  |   1 +
 .../Readers/AutoGenReaders/UsageReader.cs     |  13 +-
 .../AutoGenReaders/UseCaseDefinitionReader.cs |   1 +
 .../AutoGenReaders/UseCaseUsageReader.cs      |  25 +-
 .../AutoGenReaders/VariantMembershipReader.cs |  13 +-
 .../VerificationCaseDefinitionReader.cs       |   1 +
 .../VerificationCaseUsageReader.cs            |  25 +-
 .../AutoGenReaders/ViewDefinitionReader.cs    |   1 +
 .../ViewRenderingMembershipReader.cs          |  13 +-
 .../Readers/AutoGenReaders/ViewUsageReader.cs |  25 +-
 .../ViewpointDefinitionReader.cs              |   1 +
 .../AutoGenReaders/ViewpointUsageReader.cs    |  25 +-
 .../WhileLoopActionUsageReader.cs             |  25 +-
 200 files changed, 5292 insertions(+), 1446 deletions(-)

diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenEnumProvider/TransitionFeatureKindProvider.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenEnumProvider/TransitionFeatureKindProvider.cs
index f5ffa038f..218d1be57 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenEnumProvider/TransitionFeatureKindProvider.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenEnumProvider/TransitionFeatureKindProvider.cs
@@ -73,6 +73,48 @@ public static TransitionFeatureKind Parse(ReadOnlySpan<char> value)
             throw new ArgumentException($"'{new string(value)}' is not a valid TransitionFeatureKind", nameof(value));
         }
 
+        /// <summary>
+        /// Tries to parse the <see cref="ReadOnlySpan{Char}"/> to a <see cref="TransitionFeatureKind"/>
+        /// </summary>
+        /// <param name="value">
+        /// The <see cref="ReadOnlySpan{Char}"/> that is to be parsed
+        /// </param>
+        /// <param name="result">
+        /// When this method returns, contains the <see cref="TransitionFeatureKind"/> value equivalent
+        /// to the span, if the conversion succeeded, or <c>default</c> if the conversion failed.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="value"/> was converted successfully; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method is suited for  string parsing
+        /// There are zero allocations, no boxing, Fast short-circuit evaluation
+        /// JIT friendly
+        /// </remarks>
+        public static bool TryParse(ReadOnlySpan<char> value, out TransitionFeatureKind result)
+        {
+            if (value.Length == 7 && value.Equals("trigger".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = TransitionFeatureKind.Trigger;
+                return true;
+            }
+
+            if (value.Length == 5 && value.Equals("guard".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = TransitionFeatureKind.Guard;
+                return true;
+            }
+
+            if (value.Length == 6 && value.Equals("effect".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = TransitionFeatureKind.Effect;
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
         /// <summary>
         /// Parses the <see cref="ReadOnlySpan{Byte}"/> to a <see cref="TransitionFeatureKind"/>
         /// </summary>
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenEnumProvider/VisibilityKindProvider.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenEnumProvider/VisibilityKindProvider.cs
index 9868846be..82ee5af4b 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenEnumProvider/VisibilityKindProvider.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenEnumProvider/VisibilityKindProvider.cs
@@ -73,6 +73,48 @@ public static VisibilityKind Parse(ReadOnlySpan<char> value)
             throw new ArgumentException($"'{new string(value)}' is not a valid VisibilityKind", nameof(value));
         }
 
+        /// <summary>
+        /// Tries to parse the <see cref="ReadOnlySpan{Char}"/> to a <see cref="VisibilityKind"/>
+        /// </summary>
+        /// <param name="value">
+        /// The <see cref="ReadOnlySpan{Char}"/> that is to be parsed
+        /// </param>
+        /// <param name="result">
+        /// When this method returns, contains the <see cref="VisibilityKind"/> value equivalent
+        /// to the span, if the conversion succeeded, or <c>default</c> if the conversion failed.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="value"/> was converted successfully; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method is suited for  string parsing
+        /// There are zero allocations, no boxing, Fast short-circuit evaluation
+        /// JIT friendly
+        /// </remarks>
+        public static bool TryParse(ReadOnlySpan<char> value, out VisibilityKind result)
+        {
+            if (value.Length == 7 && value.Equals("private".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = VisibilityKind.Private;
+                return true;
+            }
+
+            if (value.Length == 9 && value.Equals("protected".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = VisibilityKind.Protected;
+                return true;
+            }
+
+            if (value.Length == 6 && value.Equals("public".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = VisibilityKind.Public;
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
         /// <summary>
         /// Parses the <see cref="ReadOnlySpan{Byte}"/> to a <see cref="VisibilityKind"/>
         /// </summary>
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AnnotatingElementReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AnnotatingElementReader.cs
index 29b22f2cd..1c93a4bfd 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AnnotatingElementReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AnnotatingElementReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -163,6 +164,10 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -179,6 +184,10 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -241,7 +250,14 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -255,8 +271,14 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -276,8 +298,14 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -289,6 +317,10 @@ public override IAnnotatingElement Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AnnotatingElement at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -393,6 +425,10 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -409,6 +445,10 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -471,7 +511,14 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,8 +532,14 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -506,8 +559,14 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -519,6 +578,10 @@ public override async Task<IAnnotatingElement> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading AnnotatingElement at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AssociationReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AssociationReader.cs
index c0d7c1a5c..700d1b020 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AssociationReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/AssociationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -197,6 +198,10 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -217,6 +222,10 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -233,6 +242,10 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -243,6 +256,10 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -305,7 +322,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -317,7 +341,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,7 +360,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -341,7 +379,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -355,8 +400,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -376,8 +427,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -397,8 +454,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -418,8 +481,14 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -431,6 +500,10 @@ public override IAssociation Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Association at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -565,6 +638,10 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -585,6 +662,10 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -601,6 +682,10 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -611,6 +696,10 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -673,7 +762,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -685,7 +781,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -697,7 +800,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -709,7 +819,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -723,8 +840,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -744,8 +867,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -765,8 +894,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -786,8 +921,14 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -799,6 +940,10 @@ public override async Task<IAssociation> ReadAsync(XmlReader xmiReader, Uri curr
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Association at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/DependencyReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/DependencyReader.cs
index 2d8a36e74..cd8e94dc0 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/DependencyReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/DependencyReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
@@ -133,6 +134,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             clientXmlAttributeReferences.Add(clientXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'client' on element {ElementId}", clientXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (clientXmlAttributeReferences.Count != 0)
@@ -194,6 +199,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -214,6 +223,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -230,6 +243,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -240,6 +257,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var supplierXmlAttribute = xmiReader.GetAttribute("supplier");
@@ -254,6 +275,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             supplierXmlAttributeReferences.Add(supplierXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'supplier' on element {ElementId}", supplierXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (supplierXmlAttributeReferences.Count != 0)
@@ -288,8 +313,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var clientId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "client", clientId);
+                                        if (Guid.TryParse(hrefSplit[1], out var clientId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "client", clientId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'client' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -343,7 +374,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -355,7 +393,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -369,8 +414,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -390,8 +441,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -411,8 +468,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -432,8 +495,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -453,8 +522,14 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var supplierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "supplier", supplierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var supplierId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "supplier", supplierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'supplier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -466,6 +541,10 @@ public override IDependency Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Dependency at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -539,6 +618,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             clientXmlAttributeReferences.Add(clientXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'client' on element {ElementId}", clientXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (clientXmlAttributeReferences.Count != 0)
@@ -600,6 +683,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -620,6 +707,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -636,6 +727,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -646,6 +741,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var supplierXmlAttribute = xmiReader.GetAttribute("supplier");
@@ -660,6 +759,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             supplierXmlAttributeReferences.Add(supplierXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'supplier' on element {ElementId}", supplierXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (supplierXmlAttributeReferences.Count != 0)
@@ -694,8 +797,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var clientId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "client", clientId);
+                                        if (Guid.TryParse(hrefSplit[1], out var clientId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "client", clientId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'client' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -749,7 +858,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -761,7 +877,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -775,8 +898,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -796,8 +925,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -817,8 +952,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -838,8 +979,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -859,8 +1006,14 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var supplierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "supplier", supplierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var supplierId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "supplier", supplierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'supplier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -872,6 +1025,10 @@ public override async Task<IDependency> ReadAsync(XmlReader xmiReader, Uri curre
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Dependency at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/EnumerationDefinitionReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/EnumerationDefinitionReader.cs
index c401061c9..2cc664a97 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/EnumerationDefinitionReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/EnumerationDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -218,6 +219,10 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -234,6 +239,10 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -296,7 +305,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -308,7 +324,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -320,7 +343,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -332,7 +362,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -346,8 +383,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -367,8 +410,14 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -380,6 +429,10 @@ public override IEnumerationDefinition Read(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading EnumerationDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -514,6 +567,10 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -530,6 +587,10 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -592,7 +653,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -604,7 +672,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -616,7 +691,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -628,7 +710,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -642,8 +731,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -663,8 +758,14 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -676,6 +777,10 @@ public override async Task<IEnumerationDefinition> ReadAsync(XmlReader xmiReader
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading EnumerationDefinition at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureReader.cs
index f1a8d5f0d..f655dbbe5 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -141,7 +142,7 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -276,6 +277,10 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -292,6 +297,10 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -342,7 +351,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -366,7 +382,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -378,7 +401,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -390,7 +420,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -402,7 +439,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -414,7 +458,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -426,7 +477,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -438,7 +496,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -450,7 +515,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -462,7 +534,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -474,7 +553,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -486,7 +572,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -500,8 +593,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -521,8 +620,14 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -534,6 +639,10 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Feature at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -613,7 +722,7 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -748,6 +857,10 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -764,6 +877,10 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -814,7 +931,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -838,7 +962,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -850,7 +981,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -862,7 +1000,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -874,7 +1019,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -886,7 +1038,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -898,7 +1057,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -910,7 +1076,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -922,7 +1095,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -934,7 +1114,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -946,7 +1133,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -958,7 +1152,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -972,8 +1173,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -993,8 +1200,14 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1006,6 +1219,10 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Feature at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureTypingReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureTypingReader.cs
index db61c6395..bd8457d6a 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureTypingReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FeatureTypingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -175,6 +176,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -195,6 +200,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -211,6 +220,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -221,6 +234,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typeXmlAttribute = xmiReader.GetAttribute("type");
@@ -231,6 +248,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'type' on element {ElementId}", typeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typedFeatureXmlAttribute = xmiReader.GetAttribute("typedFeature");
@@ -241,6 +262,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'typedFeature' on element {ElementId}", typedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -303,7 +328,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -315,7 +347,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,8 +368,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -350,8 +395,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -371,8 +422,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -392,8 +449,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -413,8 +476,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'type' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -434,8 +503,14 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'typedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -447,6 +522,10 @@ public override IFeatureTyping Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureTyping at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -561,6 +640,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -581,6 +664,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -597,6 +684,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -607,6 +698,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typeXmlAttribute = xmiReader.GetAttribute("type");
@@ -617,6 +712,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'type' on element {ElementId}", typeXmlAttribute, poco.Id);
+                    }
                 }
 
                 var typedFeatureXmlAttribute = xmiReader.GetAttribute("typedFeature");
@@ -627,6 +726,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'typedFeature' on element {ElementId}", typedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -689,7 +792,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -701,7 +811,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -715,8 +832,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -736,8 +859,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -757,8 +886,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -778,8 +913,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -799,8 +940,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typeId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typeId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "type", typeId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'type' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -820,8 +967,14 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var typedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var typedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "typedFeature", typedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'typedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -833,6 +986,10 @@ public override async Task<IFeatureTyping> ReadAsync(XmlReader xmiReader, Uri cu
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FeatureTyping at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FlowReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FlowReader.cs
index 6879e1fd2..3ce2915c5 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FlowReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FlowReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -146,7 +147,7 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -291,6 +292,10 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -311,6 +316,10 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -327,6 +336,10 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -337,6 +350,10 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -387,7 +404,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -411,7 +435,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -423,7 +454,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -435,7 +473,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -447,7 +492,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -459,7 +511,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -471,7 +530,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -483,7 +549,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -495,7 +568,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -507,7 +587,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -519,7 +606,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -531,7 +625,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -543,7 +644,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -557,8 +665,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -578,8 +692,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -599,8 +719,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -620,8 +746,14 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -633,6 +765,10 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Flow at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -712,7 +848,7 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -857,6 +993,10 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -877,6 +1017,10 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -893,6 +1037,10 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -903,6 +1051,10 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -953,7 +1105,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -977,7 +1136,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -989,7 +1155,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1001,7 +1174,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1013,7 +1193,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1025,7 +1212,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1037,7 +1231,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1049,7 +1250,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1061,7 +1269,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1073,7 +1288,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1085,7 +1307,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1097,7 +1326,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1109,7 +1345,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1123,8 +1366,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1144,8 +1393,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1165,8 +1420,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1186,8 +1447,14 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1199,6 +1466,10 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Flow at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FramedConcernMembershipReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FramedConcernMembershipReader.cs
index 2723db6d3..56e3ac930 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FramedConcernMembershipReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/FramedConcernMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.Requirements;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -171,7 +172,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out RequirementConstraintKind kindXmlAttributeAsEnum))
+                    if (RequirementConstraintKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -189,6 +190,10 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -209,6 +214,10 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -225,6 +234,10 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -235,13 +248,17 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -307,7 +324,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -319,7 +343,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -331,7 +362,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (RequirementConstraintKind)Enum.Parse(typeof(RequirementConstraintKind), kindValue, true);
+                                        if (RequirementConstraintKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -345,8 +383,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -366,8 +410,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -387,8 +437,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -408,8 +464,14 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -427,12 +489,23 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FramedConcernMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -539,7 +612,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out RequirementConstraintKind kindXmlAttributeAsEnum))
+                    if (RequirementConstraintKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -557,6 +630,10 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -577,6 +654,10 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -593,6 +674,10 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -603,13 +688,17 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -675,7 +764,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -687,7 +783,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -699,7 +802,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        poco.Kind = (RequirementConstraintKind)Enum.Parse(typeof(RequirementConstraintKind), kindValue, true);
+                                        if (RequirementConstraintKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
+                                        {
+                                            poco.Kind = kindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'kind' on element {ElementId}", kindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -713,8 +823,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -734,8 +850,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -755,8 +877,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -776,8 +904,14 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -795,12 +929,23 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading FramedConcernMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralIntegerReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralIntegerReader.cs
index d2bd9f22d..e97980cde 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralIntegerReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralIntegerReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -279,6 +280,10 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -295,6 +300,10 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -355,7 +364,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -379,7 +395,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,7 +414,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -403,7 +433,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -415,7 +452,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -427,7 +471,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -439,7 +490,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -451,7 +509,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -463,7 +528,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -475,7 +547,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -487,7 +566,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -499,7 +585,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -513,8 +606,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -534,8 +633,14 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -553,12 +658,23 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(valueValue))
                                     {
-                                        poco.Value = int.Parse(valueValue);
+                                        if (int.TryParse(valueValue, out var valueValueAsInt))
+                                        {
+                                            poco.Value = valueValueAsInt;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse int value '{Value}' for property 'value' on element {ElementId}", valueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralInteger at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -638,7 +754,7 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -773,6 +889,10 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -789,6 +909,10 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -849,7 +973,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -873,7 +1004,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -885,7 +1023,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -897,7 +1042,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -909,7 +1061,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -921,7 +1080,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -933,7 +1099,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -945,7 +1118,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -957,7 +1137,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -969,7 +1156,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -981,7 +1175,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -993,7 +1194,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1007,8 +1215,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1028,8 +1242,14 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1047,12 +1267,23 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(valueValue))
                                     {
-                                        poco.Value = int.Parse(valueValue);
+                                        if (int.TryParse(valueValue, out var valueValueAsInt))
+                                        {
+                                            poco.Value = valueValueAsInt;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse int value '{Value}' for property 'value' on element {ElementId}", valueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralInteger at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralRationalReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralRationalReader.cs
index 583ee0fd8..b08510e1f 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralRationalReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/LiteralRationalReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -279,6 +280,10 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -295,6 +300,10 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -355,7 +364,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -379,7 +395,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -391,7 +414,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -403,7 +433,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -415,7 +452,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -427,7 +471,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -439,7 +490,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -451,7 +509,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -463,7 +528,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -475,7 +547,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -487,7 +566,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -499,7 +585,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -513,8 +606,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -534,8 +633,14 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -553,12 +658,23 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(valueValue))
                                     {
-                                        poco.Value = double.Parse(valueValue);
+                                        if (double.TryParse(valueValue, out var valueValueAsDouble))
+                                        {
+                                            poco.Value = valueValueAsDouble;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse double value '{Value}' for property 'value' on element {ElementId}", valueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralRational at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -638,7 +754,7 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -773,6 +889,10 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -789,6 +909,10 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var valueXmlAttribute = xmiReader.GetAttribute("value");
@@ -849,7 +973,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -873,7 +1004,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -885,7 +1023,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -897,7 +1042,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -909,7 +1061,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -921,7 +1080,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -933,7 +1099,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -945,7 +1118,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -957,7 +1137,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -969,7 +1156,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -981,7 +1175,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -993,7 +1194,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1007,8 +1215,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1028,8 +1242,14 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1047,12 +1267,23 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(valueValue))
                                     {
-                                        poco.Value = double.Parse(valueValue);
+                                        if (double.TryParse(valueValue, out var valueValueAsDouble))
+                                        {
+                                            poco.Value = valueValueAsDouble;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse double value '{Value}' for property 'value' on element {ElementId}", valueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading LiteralRational at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MembershipReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MembershipReader.cs
index 7437fb907..ea4c13313 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MembershipReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -170,6 +171,10 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'memberElement' on element {ElementId}", memberElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var memberNameXmlAttribute = xmiReader.GetAttribute("memberName");
@@ -198,6 +203,10 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -218,6 +227,10 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -234,6 +247,10 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -244,13 +261,17 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -316,7 +337,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -328,7 +356,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -342,8 +377,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var memberElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var memberElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'memberElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -387,8 +428,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -408,8 +455,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -429,8 +482,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -450,8 +509,14 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -469,12 +534,23 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Membership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -585,6 +661,10 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'memberElement' on element {ElementId}", memberElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var memberNameXmlAttribute = xmiReader.GetAttribute("memberName");
@@ -613,6 +693,10 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -633,6 +717,10 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -649,6 +737,10 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -659,13 +751,17 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -731,7 +827,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -743,7 +846,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -757,8 +867,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var memberElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var memberElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "memberElement", memberElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'memberElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -802,8 +918,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -823,8 +945,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -844,8 +972,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -865,8 +999,14 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -884,12 +1024,23 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Membership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MultiplicityRangeReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MultiplicityRangeReader.cs
index de0bbd2aa..7e51476b2 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MultiplicityRangeReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/MultiplicityRangeReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -143,7 +144,7 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -278,6 +279,10 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -294,6 +299,10 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -344,7 +353,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -368,7 +384,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -380,7 +403,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -392,7 +422,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -404,7 +441,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -416,7 +460,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -428,7 +479,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -440,7 +498,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -452,7 +517,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -464,7 +536,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -476,7 +555,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -488,7 +574,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -502,8 +595,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -523,8 +622,14 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -536,6 +641,10 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MultiplicityRange at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -615,7 +724,7 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -750,6 +859,10 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -766,6 +879,10 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -816,7 +933,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -840,7 +964,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -852,7 +983,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -864,7 +1002,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -876,7 +1021,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -888,7 +1040,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -900,7 +1059,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -912,7 +1078,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -924,7 +1097,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -936,7 +1116,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -948,7 +1135,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -960,7 +1154,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -974,8 +1175,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -995,8 +1202,14 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1008,6 +1221,10 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading MultiplicityRange at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/OwningMembershipReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/OwningMembershipReader.cs
index c04f8ba78..b78e51826 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/OwningMembershipReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/OwningMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -174,6 +175,10 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -194,6 +199,10 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -210,6 +219,10 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -220,13 +233,17 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -292,7 +309,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -304,7 +328,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -318,8 +349,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -339,8 +376,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -360,8 +403,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -381,8 +430,14 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -400,12 +455,23 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading OwningMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -520,6 +586,10 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -540,6 +610,10 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -556,6 +630,10 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -566,13 +644,17 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var visibilityXmlAttribute = xmiReader.GetAttribute("visibility");
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -638,7 +720,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -650,7 +739,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -664,8 +760,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -685,8 +787,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -706,8 +814,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -727,8 +841,14 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -746,12 +866,23 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        poco.Visibility = (VisibilityKind)Enum.Parse(typeof(VisibilityKind), visibilityValue, true);
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
+                                        {
+                                            poco.Visibility = visibilityValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'visibility' on element {ElementId}", visibilityValue, poco.Id);
+                                        }
                                     }
 
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading OwningMembership at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/ReferenceSubsettingReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/ReferenceSubsettingReader.cs
index 2914a19b2..8d10b222d 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/ReferenceSubsettingReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/ReferenceSubsettingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -175,6 +176,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -195,6 +200,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -211,6 +220,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -221,6 +234,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var referencedFeatureXmlAttribute = xmiReader.GetAttribute("referencedFeature");
@@ -231,6 +248,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'referencedFeature' on element {ElementId}", referencedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -293,7 +314,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -305,7 +333,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -319,8 +354,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -340,8 +381,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -361,8 +408,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -382,8 +435,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -403,8 +462,14 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var referencedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var referencedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'referencedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -416,6 +481,10 @@ public override IReferenceSubsetting Read(XmlReader xmiReader, Uri currentLocati
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ReferenceSubsetting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -530,6 +599,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -550,6 +623,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -566,6 +643,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -576,6 +657,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var referencedFeatureXmlAttribute = xmiReader.GetAttribute("referencedFeature");
@@ -586,6 +671,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'referencedFeature' on element {ElementId}", referencedFeatureXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -648,7 +737,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -660,7 +756,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -674,8 +777,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -695,8 +804,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -716,8 +831,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -737,8 +858,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -758,8 +885,14 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var referencedFeatureId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureId);
+                                        if (Guid.TryParse(hrefSplit[1], out var referencedFeatureId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "referencedFeature", referencedFeatureId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'referencedFeature' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -771,6 +904,10 @@ public override async Task<IReferenceSubsetting> ReadAsync(XmlReader xmiReader,
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading ReferenceSubsetting at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/RequirementUsageReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/RequirementUsageReader.cs
index a84d9989f..1c8e6f491 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/RequirementUsageReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/RequirementUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -161,7 +162,7 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -306,6 +307,10 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -322,13 +327,17 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -377,7 +386,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -401,7 +417,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -413,7 +436,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -425,7 +455,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -437,7 +474,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -449,7 +493,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -461,7 +512,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -473,7 +531,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,7 +550,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -497,7 +569,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -509,7 +588,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -521,7 +607,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -533,7 +626,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -547,8 +647,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -568,8 +674,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -587,7 +699,14 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -605,6 +724,10 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RequirementUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -677,7 +800,7 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -822,6 +945,10 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -838,13 +965,17 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var portionKindXmlAttribute = xmiReader.GetAttribute("portionKind");
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -893,7 +1024,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -917,7 +1055,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -929,7 +1074,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -941,7 +1093,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -953,7 +1112,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -965,7 +1131,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -977,7 +1150,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -989,7 +1169,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isIndividualValue))
                                     {
-                                        poco.IsIndividual = bool.Parse(isIndividualValue);
+                                        if (bool.TryParse(isIndividualValue, out var isIndividualValueAsBool))
+                                        {
+                                            poco.IsIndividual = isIndividualValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isIndividual' on element {ElementId}", isIndividualValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1001,7 +1188,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1013,7 +1207,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1025,7 +1226,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1037,7 +1245,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1049,7 +1264,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1063,8 +1285,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1084,8 +1312,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1103,7 +1337,14 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        poco.PortionKind = (PortionKind)Enum.Parse(typeof(PortionKind), portionKindValue, true);
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
+                                        {
+                                            poco.PortionKind = portionKindValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'portionKind' on element {ElementId}", portionKindValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1121,6 +1362,10 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading RequirementUsage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SelectExpressionReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SelectExpressionReader.cs
index 683c69458..5368ea304 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SelectExpressionReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SelectExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -286,6 +287,10 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -302,6 +307,10 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -352,7 +361,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -376,7 +392,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -388,7 +411,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -400,7 +430,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -412,7 +449,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -424,7 +468,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -436,7 +487,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -448,7 +506,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -460,7 +525,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -472,7 +544,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -484,7 +563,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -496,7 +582,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -522,8 +615,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -543,8 +642,14 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -556,6 +661,10 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SelectExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -635,7 +744,7 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -777,6 +886,10 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -793,6 +906,10 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -843,7 +960,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -867,7 +991,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -879,7 +1010,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -891,7 +1029,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -903,7 +1048,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -915,7 +1067,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -927,7 +1086,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -939,7 +1105,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -951,7 +1124,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -963,7 +1143,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -975,7 +1162,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -987,7 +1181,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(isVariableValue))
                                     {
-                                        poco.IsVariable = bool.Parse(isVariableValue);
+                                        if (bool.TryParse(isVariableValue, out var isVariableValueAsBool))
+                                        {
+                                            poco.IsVariable = isVariableValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariable' on element {ElementId}", isVariableValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -1013,8 +1214,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1034,8 +1241,14 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1047,6 +1260,10 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading SelectExpression at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SubclassificationReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SubclassificationReader.cs
index 592af9d80..441c66d7b 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SubclassificationReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/SubclassificationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -175,6 +176,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -195,6 +200,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -211,6 +220,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -221,6 +234,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var subclassifierXmlAttribute = xmiReader.GetAttribute("subclassifier");
@@ -231,6 +248,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'subclassifier' on element {ElementId}", subclassifierXmlAttribute, poco.Id);
+                    }
                 }
 
                 var superclassifierXmlAttribute = xmiReader.GetAttribute("superclassifier");
@@ -241,6 +262,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'superclassifier' on element {ElementId}", superclassifierXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -303,7 +328,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -315,7 +347,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -329,8 +368,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -350,8 +395,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -371,8 +422,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -392,8 +449,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -413,8 +476,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var subclassifierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var subclassifierId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'subclassifier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -434,8 +503,14 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var superclassifierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var superclassifierId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'superclassifier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -447,6 +522,10 @@ public override ISubclassification Read(XmlReader xmiReader, Uri currentLocation
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Subclassification at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -561,6 +640,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelatedElementXmlAttributeReferences.Add(ownedRelatedElementXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelatedElement' on element {ElementId}", ownedRelatedElementXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelatedElementXmlAttributeReferences.Count != 0)
@@ -581,6 +664,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -597,6 +684,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelatedElement' on element {ElementId}", owningRelatedElementXmlAttribute, poco.Id);
+                    }
                 }
 
                 var owningRelationshipXmlAttribute = xmiReader.GetAttribute("owningRelationship");
@@ -607,6 +698,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 var subclassifierXmlAttribute = xmiReader.GetAttribute("subclassifier");
@@ -617,6 +712,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'subclassifier' on element {ElementId}", subclassifierXmlAttribute, poco.Id);
+                    }
                 }
 
                 var superclassifierXmlAttribute = xmiReader.GetAttribute("superclassifier");
@@ -627,6 +726,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'superclassifier' on element {ElementId}", superclassifierXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -689,7 +792,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedValue))
                                     {
-                                        poco.IsImplied = bool.Parse(isImpliedValue);
+                                        if (bool.TryParse(isImpliedValue, out var isImpliedValueAsBool))
+                                        {
+                                            poco.IsImplied = isImpliedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImplied' on element {ElementId}", isImpliedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -701,7 +811,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -715,8 +832,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelatedElementId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelatedElement", ownedRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -736,8 +859,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -757,8 +886,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelatedElementId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelatedElementId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelatedElement", owningRelatedElementId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelatedElement' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -778,8 +913,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -799,8 +940,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var subclassifierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var subclassifierId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "subclassifier", subclassifierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'subclassifier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -820,8 +967,14 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var superclassifierId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierId);
+                                        if (Guid.TryParse(hrefSplit[1], out var superclassifierId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "superclassifier", superclassifierId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'superclassifier' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -833,6 +986,10 @@ public override async Task<ISubclassification> ReadAsync(XmlReader xmiReader, Ur
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Subclassification at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/TextualRepresentationReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/TextualRepresentationReader.cs
index f97035a71..7e84e4777 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/TextualRepresentationReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/TextualRepresentationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -177,6 +178,10 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -193,6 +198,10 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -267,7 +276,14 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -293,8 +309,14 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -314,8 +336,14 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -327,6 +355,10 @@ public override ITextualRepresentation Read(XmlReader xmiReader, Uri currentLoca
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TextualRepresentation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -445,6 +477,10 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -461,6 +497,10 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -535,7 +575,14 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -561,8 +608,14 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -582,8 +635,14 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -595,6 +654,10 @@ public override async Task<ITextualRepresentation> ReadAsync(XmlReader xmiReader
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading TextualRepresentation at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/UsageReader.cs b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/UsageReader.cs
index 076911158..c5d989531 100644
--- a/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/UsageReader.cs
+++ b/SysML2.NET.CodeGenerator.Tests/Expected/UML/Core/AutoGenReaders/UsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -164,7 +165,7 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -299,6 +300,10 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -315,6 +320,10 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (xmiReader.Read())
@@ -365,7 +374,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -389,7 +405,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -401,7 +424,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -413,7 +443,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -425,7 +462,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -437,7 +481,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -449,7 +500,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -461,7 +519,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -473,7 +538,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -485,7 +557,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -497,7 +576,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -509,7 +595,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -523,8 +616,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -544,8 +643,14 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -557,6 +662,10 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Usage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                xmiReader.Skip();
+                                break;
                         }
                     }
                 }
@@ -636,7 +745,7 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -771,6 +880,10 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                         {
                             ownedRelationshipXmlAttributeReferences.Add(ownedRelationshipXmlAttributeReference);
                         }
+                        else
+                        {
+                            this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'ownedRelationship' on element {ElementId}", ownedRelationshipXmlAttributeValue, poco.Id);
+                        }
                     }
 
                     if (ownedRelationshipXmlAttributeReferences.Count != 0)
@@ -787,6 +900,10 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                     {
                         this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipXmlAttributeReference);
                     }
+                    else
+                    {
+                        this.logger.LogWarning("Failed to parse GUID reference value '{Value}' for property 'owningRelationship' on element {ElementId}", owningRelationshipXmlAttribute, poco.Id);
+                    }
                 }
 
                 while (await xmiReader.ReadAsync())
@@ -837,7 +954,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        poco.Direction = (FeatureDirectionKind)Enum.Parse(typeof(FeatureDirectionKind), directionValue, true);
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
+                                        {
+                                            poco.Direction = directionValueAsEnum;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse enum value '{Value}' for property 'direction' on element {ElementId}", directionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -861,7 +985,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isAbstractValue))
                                     {
-                                        poco.IsAbstract = bool.Parse(isAbstractValue);
+                                        if (bool.TryParse(isAbstractValue, out var isAbstractValueAsBool))
+                                        {
+                                            poco.IsAbstract = isAbstractValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isAbstract' on element {ElementId}", isAbstractValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -873,7 +1004,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isCompositeValue))
                                     {
-                                        poco.IsComposite = bool.Parse(isCompositeValue);
+                                        if (bool.TryParse(isCompositeValue, out var isCompositeValueAsBool))
+                                        {
+                                            poco.IsComposite = isCompositeValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isComposite' on element {ElementId}", isCompositeValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -885,7 +1023,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isConstantValue))
                                     {
-                                        poco.IsConstant = bool.Parse(isConstantValue);
+                                        if (bool.TryParse(isConstantValue, out var isConstantValueAsBool))
+                                        {
+                                            poco.IsConstant = isConstantValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isConstant' on element {ElementId}", isConstantValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -897,7 +1042,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isDerivedValue))
                                     {
-                                        poco.IsDerived = bool.Parse(isDerivedValue);
+                                        if (bool.TryParse(isDerivedValue, out var isDerivedValueAsBool))
+                                        {
+                                            poco.IsDerived = isDerivedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isDerived' on element {ElementId}", isDerivedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -909,7 +1061,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isEndValue))
                                     {
-                                        poco.IsEnd = bool.Parse(isEndValue);
+                                        if (bool.TryParse(isEndValue, out var isEndValueAsBool))
+                                        {
+                                            poco.IsEnd = isEndValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isEnd' on element {ElementId}", isEndValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -921,7 +1080,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isImpliedIncludedValue))
                                     {
-                                        poco.IsImpliedIncluded = bool.Parse(isImpliedIncludedValue);
+                                        if (bool.TryParse(isImpliedIncludedValue, out var isImpliedIncludedValueAsBool))
+                                        {
+                                            poco.IsImpliedIncluded = isImpliedIncludedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isImpliedIncluded' on element {ElementId}", isImpliedIncludedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -933,7 +1099,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isOrderedValue))
                                     {
-                                        poco.IsOrdered = bool.Parse(isOrderedValue);
+                                        if (bool.TryParse(isOrderedValue, out var isOrderedValueAsBool))
+                                        {
+                                            poco.IsOrdered = isOrderedValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isOrdered' on element {ElementId}", isOrderedValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -945,7 +1118,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isPortionValue))
                                     {
-                                        poco.IsPortion = bool.Parse(isPortionValue);
+                                        if (bool.TryParse(isPortionValue, out var isPortionValueAsBool))
+                                        {
+                                            poco.IsPortion = isPortionValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isPortion' on element {ElementId}", isPortionValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -957,7 +1137,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isSufficientValue))
                                     {
-                                        poco.IsSufficient = bool.Parse(isSufficientValue);
+                                        if (bool.TryParse(isSufficientValue, out var isSufficientValueAsBool))
+                                        {
+                                            poco.IsSufficient = isSufficientValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isSufficient' on element {ElementId}", isSufficientValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -969,7 +1156,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isUniqueValue))
                                     {
-                                        poco.IsUnique = bool.Parse(isUniqueValue);
+                                        if (bool.TryParse(isUniqueValue, out var isUniqueValueAsBool))
+                                        {
+                                            poco.IsUnique = isUniqueValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isUnique' on element {ElementId}", isUniqueValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -981,7 +1175,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(isVariationValue))
                                     {
-                                        poco.IsVariation = bool.Parse(isVariationValue);
+                                        if (bool.TryParse(isVariationValue, out var isVariationValueAsBool))
+                                        {
+                                            poco.IsVariation = isVariationValueAsBool;
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse bool value '{Value}' for property 'isVariation' on element {ElementId}", isVariationValue, poco.Id);
+                                        }
                                     }
 
                                     break;
@@ -995,8 +1196,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var ownedRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var ownedRelationshipId))
+                                        {
+                                            this.Cache.AddMultipleValueReferencePropertyIdentifiers(poco.Id, "ownedRelationship", ownedRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'ownedRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1016,8 +1223,14 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     {
                                         var hrefSplit = hrefAttribute.Split('#');
                                         this.ExternalReferenceService.AddExternalReferenceToProcess(currentLocation, hrefSplit[0]);
-                                        var owningRelationshipId = Guid.Parse(hrefSplit[1]);
-                                        this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        if (Guid.TryParse(hrefSplit[1], out var owningRelationshipId))
+                                        {
+                                            this.Cache.AddSingleValueReferencePropertyIdentifier(poco.Id, "owningRelationship", owningRelationshipId);
+                                        }
+                                        else
+                                        {
+                                            this.logger.LogWarning("Failed to parse href GUID value '{HrefValue}' for property 'owningRelationship' on element {ElementId}", hrefSplit[1], poco.Id);
+                                        }
                                     }
                                     else
                                     {
@@ -1029,6 +1242,10 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
                                     break;
                                 }
 
+                            default:
+                                this.logger.LogWarning("Unexpected element '{LocalName}' encountered while reading Usage at line:position {LineNumber}:{LinePosition}", xmiReader.LocalName, xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+                                await xmiReader.SkipAsync();
+                                break;
                         }
                     }
                 }
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-attribute-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-attribute-template.hbs
index d832881ff..3c34ee8a8 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-attribute-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-attribute-template.hbs
@@ -42,7 +42,7 @@ if(!string.IsNullOrWhiteSpace({{String.LowerCaseFirstLetter property.Name}}XmlAt
                     poco.{{Property.WritePropertyName property}}.Add({{String.LowerCaseFirstLetter property.Name}}XmlAttributeValueAsBool);
                 }
         {{else if (Property.QueryIsEnum property )}}
-                if(Enum.TryParse({{String.LowerCaseFirstLetter property.Name}}XmlAttributeValue, true, out {{property.Type.Name}} {{String.LowerCaseFirstLetter property.Name}}XmlAttributeValueAsEnum))
+                if({{property.Type.Name}}Provider.TryParse({{String.LowerCaseFirstLetter property.Name}}XmlAttributeValue.AsSpan(), out var {{String.LowerCaseFirstLetter property.Name}}XmlAttributeValueAsEnum))
                 {
                     poco.{{Property.WritePropertyName property}}.Add({{String.LowerCaseFirstLetter property.Name}}XmlAttributeValueAsEnum);
                 }
@@ -71,7 +71,7 @@ if(!string.IsNullOrWhiteSpace({{String.LowerCaseFirstLetter property.Name}}XmlAt
                 poco.{{Property.WritePropertyName property}} = {{String.LowerCaseFirstLetter property.Name}}XmlAttributeAsBool;
             }
         {{else if (Property.QueryIsEnum property )}}
-                if(Enum.TryParse({{String.LowerCaseFirstLetter property.Name}}XmlAttribute, true, out {{property.Type.Name}} {{String.LowerCaseFirstLetter property.Name}}XmlAttributeAsEnum))
+                if({{property.Type.Name}}Provider.TryParse({{String.LowerCaseFirstLetter property.Name}}XmlAttribute.AsSpan(), out var {{String.LowerCaseFirstLetter property.Name}}XmlAttributeAsEnum))
                 {
                 poco.{{Property.WritePropertyName property}} = {{String.LowerCaseFirstLetter property.Name}}XmlAttributeAsEnum;
                 }
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs
index 8f86a3cf5..68f925690 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/Partials/core-xmi-reader-partial-for-element-template.hbs
@@ -62,9 +62,9 @@ case"{{String.LowerCaseFirstLetter property.Name}}":
                 this.logger.LogWarning("Failed to parse bool value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}Value, poco.Id);
             }
         {{else if (Property.QueryIsEnum property )}}
-            if(Enum.TryParse(typeof({{property.Type.Name}}), {{String.LowerCaseFirstLetter property.Name}}Value, true, out var {{String.LowerCaseFirstLetter property.Name}}ValueAsEnum))
+            if({{property.Type.Name}}Provider.TryParse({{String.LowerCaseFirstLetter property.Name}}Value.AsSpan(), out var {{String.LowerCaseFirstLetter property.Name}}ValueAsEnum))
             {
-                poco.{{Property.WritePropertyName property}}.Add(({{property.Type.Name}}){{String.LowerCaseFirstLetter property.Name}}ValueAsEnum);
+                poco.{{Property.WritePropertyName property}}.Add({{String.LowerCaseFirstLetter property.Name}}ValueAsEnum);
             }
             else
             {
@@ -106,9 +106,9 @@ case"{{String.LowerCaseFirstLetter property.Name}}":
                 this.logger.LogWarning("Failed to parse bool value '{Value}' for property '{{String.LowerCaseFirstLetter property.Name}}' on element {ElementId}", {{String.LowerCaseFirstLetter property.Name}}Value, poco.Id);
             }
         {{else if (Property.QueryIsEnum property )}}
-            if(Enum.TryParse(typeof({{property.Type.Name}}), {{String.LowerCaseFirstLetter property.Name}}Value, true, out var {{String.LowerCaseFirstLetter property.Name}}ValueAsEnum))
+            if({{property.Type.Name}}Provider.TryParse({{String.LowerCaseFirstLetter property.Name}}Value.AsSpan(), out var {{String.LowerCaseFirstLetter property.Name}}ValueAsEnum))
             {
-                poco.{{Property.WritePropertyName property}} = ({{property.Type.Name}}){{String.LowerCaseFirstLetter property.Name}}ValueAsEnum;
+                poco.{{Property.WritePropertyName property}} = {{String.LowerCaseFirstLetter property.Name}}ValueAsEnum;
             }
             else
             {
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-enumprovider-uml-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-enumprovider-uml-template.hbs
index b67b1e976..205bd01f5 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-enumprovider-uml-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-enumprovider-uml-template.hbs
@@ -65,6 +65,38 @@ namespace SysML2.NET.Extensions.Core
             throw new ArgumentException($"'{new string(value)}' is not a valid {{ this.Name }}", nameof(value));
         }
 
+        /// <summary>
+        /// Tries to parse the <see cref="ReadOnlySpan{Char}"/> to a <see cref="{{ this.Name }}"/>
+        /// </summary>
+        /// <param name="value">
+        /// The <see cref="ReadOnlySpan{Char}"/> that is to be parsed
+        /// </param>
+        /// <param name="result">
+        /// When this method returns, contains the <see cref="{{ this.Name }}"/> value equivalent
+        /// to the span, if the conversion succeeded, or <c>default</c> if the conversion failed.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="value"/> was converted successfully; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method is suited for  string parsing
+        /// There are zero allocations, no boxing, Fast short-circuit evaluation
+        /// JIT friendly
+        /// </remarks>
+        public static bool TryParse(ReadOnlySpan<char> value, out {{ this.Name }} result)
+        {
+            {{ #each this.OwnedLiteral as | enumerationLiteral | }}
+            if (value.Length == {{ String.Length enumerationLiteral.Name }} && value.Equals("{{ enumerationLiteral.Name }}".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = {{ ../Name }}.{{ #EnumerationLiteral.Write enumerationLiteral }};
+                return true;
+            }
+
+            {{/each}}
+            result = default;
+            return false;
+        }
+
         /// <summary>
         /// Parses the <see cref="ReadOnlySpan{Byte}"/> to a <see cref="{{ this.Name }}"/>
         /// </summary>
diff --git a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs
index 55622c7d1..939f15a45 100644
--- a/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs
+++ b/SysML2.NET.CodeGenerator/Templates/Uml/core-xmi-reader-template.hbs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     {{ #Class.WriteEnumerationNameSpaces this}}
     {{ #Class.WriteNameSpaces this POCO}}
     using SysML2.NET.Core.POCO.{{ #NamedElement.WriteFullyQualifiedNameSpace this }};
diff --git a/SysML2.NET.Extensions.Tests/Core/EnumProvider/VisibilityKindProviderTestFixture.cs b/SysML2.NET.Extensions.Tests/Core/EnumProvider/VisibilityKindProviderTestFixture.cs
index 3da28463a..fba181686 100644
--- a/SysML2.NET.Extensions.Tests/Core/EnumProvider/VisibilityKindProviderTestFixture.cs
+++ b/SysML2.NET.Extensions.Tests/Core/EnumProvider/VisibilityKindProviderTestFixture.cs
@@ -48,6 +48,29 @@ public void Verify_that_enumvalue_throws_exception_from_unknown_string()
             Assert.That(() => VisibilityKindProvider.Parse("Starion"), Throws.ArgumentException);
         }
 
+        [Test]
+        [TestCase("Private", VisibilityKind.Private)]
+        [TestCase("Protected", VisibilityKind.Protected)]
+        [TestCase("Public", VisibilityKind.Public)]
+        [TestCase("private", VisibilityKind.Private)]
+        [TestCase("protected", VisibilityKind.Protected)]
+        [TestCase("public", VisibilityKind.Public)]
+        public void Verify_that_TryParse_returns_true_for_valid_value(string input, VisibilityKind expected)
+        {
+            Assert.That(VisibilityKindProvider.TryParse(input.AsSpan(), out var result), Is.True);
+            Assert.That(result, Is.EqualTo(expected));
+        }
+
+        [Test]
+        [TestCase("Starion")]
+        [TestCase("")]
+        [TestCase("internal")]
+        public void Verify_that_TryParse_returns_false_for_invalid_value(string input)
+        {
+            Assert.That(VisibilityKindProvider.TryParse(input.AsSpan(), out var result), Is.False);
+            Assert.That(result, Is.EqualTo(default(VisibilityKind)));
+        }
+
         [Test]
         [TestCase("private", VisibilityKind.Private)]
         [TestCase("protected", VisibilityKind.Protected)]
diff --git a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/FeatureDirectionKindProvider.cs b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/FeatureDirectionKindProvider.cs
index bf47ec02e..c4efd0c5f 100644
--- a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/FeatureDirectionKindProvider.cs
+++ b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/FeatureDirectionKindProvider.cs
@@ -73,6 +73,48 @@ public static FeatureDirectionKind Parse(ReadOnlySpan<char> value)
             throw new ArgumentException($"'{new string(value)}' is not a valid FeatureDirectionKind", nameof(value));
         }
 
+        /// <summary>
+        /// Tries to parse the <see cref="ReadOnlySpan{Char}"/> to a <see cref="FeatureDirectionKind"/>
+        /// </summary>
+        /// <param name="value">
+        /// The <see cref="ReadOnlySpan{Char}"/> that is to be parsed
+        /// </param>
+        /// <param name="result">
+        /// When this method returns, contains the <see cref="FeatureDirectionKind"/> value equivalent
+        /// to the span, if the conversion succeeded, or <c>default</c> if the conversion failed.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="value"/> was converted successfully; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method is suited for  string parsing
+        /// There are zero allocations, no boxing, Fast short-circuit evaluation
+        /// JIT friendly
+        /// </remarks>
+        public static bool TryParse(ReadOnlySpan<char> value, out FeatureDirectionKind result)
+        {
+            if (value.Length == 2 && value.Equals("in".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = FeatureDirectionKind.In;
+                return true;
+            }
+
+            if (value.Length == 5 && value.Equals("inout".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = FeatureDirectionKind.Inout;
+                return true;
+            }
+
+            if (value.Length == 3 && value.Equals("out".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = FeatureDirectionKind.Out;
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
         /// <summary>
         /// Parses the <see cref="ReadOnlySpan{Byte}"/> to a <see cref="FeatureDirectionKind"/>
         /// </summary>
diff --git a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/PortionKindProvider.cs b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/PortionKindProvider.cs
index ce09d45fb..f3d94dd02 100644
--- a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/PortionKindProvider.cs
+++ b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/PortionKindProvider.cs
@@ -68,6 +68,42 @@ public static PortionKind Parse(ReadOnlySpan<char> value)
             throw new ArgumentException($"'{new string(value)}' is not a valid PortionKind", nameof(value));
         }
 
+        /// <summary>
+        /// Tries to parse the <see cref="ReadOnlySpan{Char}"/> to a <see cref="PortionKind"/>
+        /// </summary>
+        /// <param name="value">
+        /// The <see cref="ReadOnlySpan{Char}"/> that is to be parsed
+        /// </param>
+        /// <param name="result">
+        /// When this method returns, contains the <see cref="PortionKind"/> value equivalent
+        /// to the span, if the conversion succeeded, or <c>default</c> if the conversion failed.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="value"/> was converted successfully; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method is suited for  string parsing
+        /// There are zero allocations, no boxing, Fast short-circuit evaluation
+        /// JIT friendly
+        /// </remarks>
+        public static bool TryParse(ReadOnlySpan<char> value, out PortionKind result)
+        {
+            if (value.Length == 9 && value.Equals("timeslice".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = PortionKind.Timeslice;
+                return true;
+            }
+
+            if (value.Length == 8 && value.Equals("snapshot".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = PortionKind.Snapshot;
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
         /// <summary>
         /// Parses the <see cref="ReadOnlySpan{Byte}"/> to a <see cref="PortionKind"/>
         /// </summary>
diff --git a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/RequirementConstraintKindProvider.cs b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/RequirementConstraintKindProvider.cs
index 3fbf53825..041c24322 100644
--- a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/RequirementConstraintKindProvider.cs
+++ b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/RequirementConstraintKindProvider.cs
@@ -68,6 +68,42 @@ public static RequirementConstraintKind Parse(ReadOnlySpan<char> value)
             throw new ArgumentException($"'{new string(value)}' is not a valid RequirementConstraintKind", nameof(value));
         }
 
+        /// <summary>
+        /// Tries to parse the <see cref="ReadOnlySpan{Char}"/> to a <see cref="RequirementConstraintKind"/>
+        /// </summary>
+        /// <param name="value">
+        /// The <see cref="ReadOnlySpan{Char}"/> that is to be parsed
+        /// </param>
+        /// <param name="result">
+        /// When this method returns, contains the <see cref="RequirementConstraintKind"/> value equivalent
+        /// to the span, if the conversion succeeded, or <c>default</c> if the conversion failed.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="value"/> was converted successfully; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method is suited for  string parsing
+        /// There are zero allocations, no boxing, Fast short-circuit evaluation
+        /// JIT friendly
+        /// </remarks>
+        public static bool TryParse(ReadOnlySpan<char> value, out RequirementConstraintKind result)
+        {
+            if (value.Length == 10 && value.Equals("assumption".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = RequirementConstraintKind.Assumption;
+                return true;
+            }
+
+            if (value.Length == 11 && value.Equals("requirement".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = RequirementConstraintKind.Requirement;
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
         /// <summary>
         /// Parses the <see cref="ReadOnlySpan{Byte}"/> to a <see cref="RequirementConstraintKind"/>
         /// </summary>
diff --git a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/StateSubactionKindProvider.cs b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/StateSubactionKindProvider.cs
index d40fbf511..f392c1a1a 100644
--- a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/StateSubactionKindProvider.cs
+++ b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/StateSubactionKindProvider.cs
@@ -73,6 +73,48 @@ public static StateSubactionKind Parse(ReadOnlySpan<char> value)
             throw new ArgumentException($"'{new string(value)}' is not a valid StateSubactionKind", nameof(value));
         }
 
+        /// <summary>
+        /// Tries to parse the <see cref="ReadOnlySpan{Char}"/> to a <see cref="StateSubactionKind"/>
+        /// </summary>
+        /// <param name="value">
+        /// The <see cref="ReadOnlySpan{Char}"/> that is to be parsed
+        /// </param>
+        /// <param name="result">
+        /// When this method returns, contains the <see cref="StateSubactionKind"/> value equivalent
+        /// to the span, if the conversion succeeded, or <c>default</c> if the conversion failed.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="value"/> was converted successfully; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method is suited for  string parsing
+        /// There are zero allocations, no boxing, Fast short-circuit evaluation
+        /// JIT friendly
+        /// </remarks>
+        public static bool TryParse(ReadOnlySpan<char> value, out StateSubactionKind result)
+        {
+            if (value.Length == 5 && value.Equals("entry".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = StateSubactionKind.Entry;
+                return true;
+            }
+
+            if (value.Length == 2 && value.Equals("do".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = StateSubactionKind.Do;
+                return true;
+            }
+
+            if (value.Length == 4 && value.Equals("exit".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = StateSubactionKind.Exit;
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
         /// <summary>
         /// Parses the <see cref="ReadOnlySpan{Byte}"/> to a <see cref="StateSubactionKind"/>
         /// </summary>
diff --git a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/TransitionFeatureKindProvider.cs b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/TransitionFeatureKindProvider.cs
index f5ffa038f..218d1be57 100644
--- a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/TransitionFeatureKindProvider.cs
+++ b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/TransitionFeatureKindProvider.cs
@@ -73,6 +73,48 @@ public static TransitionFeatureKind Parse(ReadOnlySpan<char> value)
             throw new ArgumentException($"'{new string(value)}' is not a valid TransitionFeatureKind", nameof(value));
         }
 
+        /// <summary>
+        /// Tries to parse the <see cref="ReadOnlySpan{Char}"/> to a <see cref="TransitionFeatureKind"/>
+        /// </summary>
+        /// <param name="value">
+        /// The <see cref="ReadOnlySpan{Char}"/> that is to be parsed
+        /// </param>
+        /// <param name="result">
+        /// When this method returns, contains the <see cref="TransitionFeatureKind"/> value equivalent
+        /// to the span, if the conversion succeeded, or <c>default</c> if the conversion failed.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="value"/> was converted successfully; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method is suited for  string parsing
+        /// There are zero allocations, no boxing, Fast short-circuit evaluation
+        /// JIT friendly
+        /// </remarks>
+        public static bool TryParse(ReadOnlySpan<char> value, out TransitionFeatureKind result)
+        {
+            if (value.Length == 7 && value.Equals("trigger".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = TransitionFeatureKind.Trigger;
+                return true;
+            }
+
+            if (value.Length == 5 && value.Equals("guard".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = TransitionFeatureKind.Guard;
+                return true;
+            }
+
+            if (value.Length == 6 && value.Equals("effect".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = TransitionFeatureKind.Effect;
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
         /// <summary>
         /// Parses the <see cref="ReadOnlySpan{Byte}"/> to a <see cref="TransitionFeatureKind"/>
         /// </summary>
diff --git a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/TriggerKindProvider.cs b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/TriggerKindProvider.cs
index 4bfda599f..db83aa8d8 100644
--- a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/TriggerKindProvider.cs
+++ b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/TriggerKindProvider.cs
@@ -73,6 +73,48 @@ public static TriggerKind Parse(ReadOnlySpan<char> value)
             throw new ArgumentException($"'{new string(value)}' is not a valid TriggerKind", nameof(value));
         }
 
+        /// <summary>
+        /// Tries to parse the <see cref="ReadOnlySpan{Char}"/> to a <see cref="TriggerKind"/>
+        /// </summary>
+        /// <param name="value">
+        /// The <see cref="ReadOnlySpan{Char}"/> that is to be parsed
+        /// </param>
+        /// <param name="result">
+        /// When this method returns, contains the <see cref="TriggerKind"/> value equivalent
+        /// to the span, if the conversion succeeded, or <c>default</c> if the conversion failed.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="value"/> was converted successfully; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method is suited for  string parsing
+        /// There are zero allocations, no boxing, Fast short-circuit evaluation
+        /// JIT friendly
+        /// </remarks>
+        public static bool TryParse(ReadOnlySpan<char> value, out TriggerKind result)
+        {
+            if (value.Length == 4 && value.Equals("when".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = TriggerKind.When;
+                return true;
+            }
+
+            if (value.Length == 2 && value.Equals("at".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = TriggerKind.At;
+                return true;
+            }
+
+            if (value.Length == 5 && value.Equals("after".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = TriggerKind.After;
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
         /// <summary>
         /// Parses the <see cref="ReadOnlySpan{Byte}"/> to a <see cref="TriggerKind"/>
         /// </summary>
diff --git a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/VisibilityKindProvider.cs b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/VisibilityKindProvider.cs
index 9868846be..82ee5af4b 100644
--- a/SysML2.NET.Extensions/Core/AutoGenEnumProvider/VisibilityKindProvider.cs
+++ b/SysML2.NET.Extensions/Core/AutoGenEnumProvider/VisibilityKindProvider.cs
@@ -73,6 +73,48 @@ public static VisibilityKind Parse(ReadOnlySpan<char> value)
             throw new ArgumentException($"'{new string(value)}' is not a valid VisibilityKind", nameof(value));
         }
 
+        /// <summary>
+        /// Tries to parse the <see cref="ReadOnlySpan{Char}"/> to a <see cref="VisibilityKind"/>
+        /// </summary>
+        /// <param name="value">
+        /// The <see cref="ReadOnlySpan{Char}"/> that is to be parsed
+        /// </param>
+        /// <param name="result">
+        /// When this method returns, contains the <see cref="VisibilityKind"/> value equivalent
+        /// to the span, if the conversion succeeded, or <c>default</c> if the conversion failed.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="value"/> was converted successfully; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method is suited for  string parsing
+        /// There are zero allocations, no boxing, Fast short-circuit evaluation
+        /// JIT friendly
+        /// </remarks>
+        public static bool TryParse(ReadOnlySpan<char> value, out VisibilityKind result)
+        {
+            if (value.Length == 7 && value.Equals("private".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = VisibilityKind.Private;
+                return true;
+            }
+
+            if (value.Length == 9 && value.Equals("protected".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = VisibilityKind.Protected;
+                return true;
+            }
+
+            if (value.Length == 6 && value.Equals("public".AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                result = VisibilityKind.Public;
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
         /// <summary>
         /// Parses the <see cref="ReadOnlySpan{Byte}"/> to a <see cref="VisibilityKind"/>
         /// </summary>
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs
index 730ab801c..4e90f4101 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AcceptActionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IAcceptActionUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IAcceptActionUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs
index f1b68547a..fd460a217 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs
index a4a91e505..e10dcc4df 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -342,7 +343,7 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -396,9 +397,9 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -709,9 +710,9 @@ public override IActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -805,7 +806,7 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -980,7 +981,7 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1034,9 +1035,9 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1347,9 +1348,9 @@ public override async Task<IActionUsage> ReadAsync(XmlReader xmiReader, Uri curr
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs
index b26597325..a1a308090 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ActorMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -247,7 +248,7 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -459,9 +460,9 @@ public override IActorMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -658,7 +659,7 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -870,9 +871,9 @@ public override async Task<IActorMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs
index 3a8462a61..664625228 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs
index db73bbe4e..1e3c568bf 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AllocationUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -169,7 +170,7 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -392,7 +393,7 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -446,9 +447,9 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -832,9 +833,9 @@ public override IAllocationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -928,7 +929,7 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1151,7 +1152,7 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1205,9 +1206,9 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1591,9 +1592,9 @@ public override async Task<IAllocationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs
index 241015227..08866a976 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs
index e928c8c05..bf2d5266f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnalysisCaseUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IAnalysisCaseUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IAnalysisCaseUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs
index 42426a37d..1c93a4bfd 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotatingElementReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs
index 93b305aa4..e3dd30223 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AnnotationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs
index 68518f70e..2278487c5 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssertConstraintUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -353,7 +354,7 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -407,9 +408,9 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -739,9 +740,9 @@ public override IAssertConstraintUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -835,7 +836,7 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1020,7 +1021,7 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1074,9 +1075,9 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1406,9 +1407,9 @@ public override async Task<IAssertConstraintUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs
index 631bebe42..e6cdb3cf0 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssignmentActionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IAssignmentActionUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IAssignmentActionUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs
index 66ca8d6a6..700d1b020 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs
index 9e6ebc3a6..5ec1707ef 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AssociationStructureReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs
index 4e558dd47..4fed79314 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs
index 0bd97f3bc..a237b0ed0 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/AttributeUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -165,7 +166,7 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -374,9 +375,9 @@ public override IAttributeUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -745,7 +746,7 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -954,9 +955,9 @@ public override async Task<IAttributeUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs
index c87cd2012..def4280dc 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BehaviorReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs
index 60412af40..b8c2f51df 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorAsUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -166,7 +167,7 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -423,9 +424,9 @@ public override IBindingConnectorAsUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -867,7 +868,7 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1124,9 +1125,9 @@ public override async Task<IBindingConnectorAsUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs
index a76af3a7b..ea3ce3a1f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BindingConnectorReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -143,7 +144,7 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -400,9 +401,9 @@ public override IBindingConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -844,7 +845,7 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1101,9 +1102,9 @@ public override async Task<IBindingConnector> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs
index 454f8320c..058f710e5 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/BooleanExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -143,7 +144,7 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -352,9 +353,9 @@ public override IBooleanExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -723,7 +724,7 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -932,9 +933,9 @@ public override async Task<IBooleanExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs
index 8485283f9..9e783f04c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs
index e589bd96a..bb67e0d3a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CalculationUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override ICalculationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<ICalculationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs
index fdb90d4cd..4a315d760 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs
index 785484ffd..6340e20ec 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CaseUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override ICaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<ICaseUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs
index 0e2cecede..3733410fa 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs
index db8686182..2bf820e53 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ClassifierReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs
index 4c6e892a7..a5dabe1d7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CollectExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -360,9 +361,9 @@ public override ICollectExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -743,7 +744,7 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -959,9 +960,9 @@ public override async Task<ICollectExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs
index ad0d45e9d..63b2e39b8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CommentReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs
index 3b248a833..827d08f30 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs
index b77251a0c..dfc817ccf 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConcernUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -161,7 +162,7 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -336,7 +337,7 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -385,9 +386,9 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -698,9 +699,9 @@ public override IConcernUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -799,7 +800,7 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -974,7 +975,7 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1023,9 +1024,9 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1336,9 +1337,9 @@ public override async Task<IConcernUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs
index 3e0458326..f7703d610 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs
index f3629e05c..36640d8d1 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugatedPortTypingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs
index d427ec163..434662a93 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConjugationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs
index 4f1f3d7ce..40806fc5c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs
index 56180ac7c..47fd74d0e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -169,7 +170,7 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -392,7 +393,7 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -446,9 +447,9 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -832,9 +833,9 @@ public override IConnectionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -928,7 +929,7 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1151,7 +1152,7 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1205,9 +1206,9 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1591,9 +1592,9 @@ public override async Task<IConnectionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs
index 7d0e03566..864312aec 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConnectorReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -143,7 +144,7 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -400,9 +401,9 @@ public override IConnector Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -844,7 +845,7 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1101,9 +1102,9 @@ public override async Task<IConnector> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs
index cac4a6be8..7bd34e8e3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs
index 2bb033fd5..a71080d15 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstraintUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IConstraintUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IConstraintUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs
index e663b24f9..220345ab3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ConstructorExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -353,9 +354,9 @@ public override IConstructorExpression Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -724,7 +725,7 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -933,9 +934,9 @@ public override async Task<IConstructorExpression> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs
index 5fab7ed2a..7cda6c3e2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/CrossSubsettingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs
index b66f57b36..291e95ec6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DataTypeReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs
index d910eaf7c..cb0331b16 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DecisionNodeReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -342,7 +343,7 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -396,9 +397,9 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -709,9 +710,9 @@ public override IDecisionNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -805,7 +806,7 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -980,7 +981,7 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1034,9 +1035,9 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1347,9 +1348,9 @@ public override async Task<IDecisionNode> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs
index 5b99b86c8..b7aec2179 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs
index f2d478827..cd8e94dc0 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DependencyReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs
index 9297a3b28..0da16bfdf 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DifferencingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs
index a235b9a86..ff2824fbe 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DisjoiningReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs
index 8f0068021..3c9e019c0 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/DocumentationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs
index d0f42cd7b..90f7ef2a3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ElementFilterMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -244,7 +245,7 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -456,9 +457,9 @@ public override IElementFilterMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -655,7 +656,7 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -867,9 +868,9 @@ public override async Task<IElementFilterMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs
index 50f320b4a..54b039cf9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EndFeatureMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -244,7 +245,7 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -456,9 +457,9 @@ public override IEndFeatureMembership Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -655,7 +656,7 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -867,9 +868,9 @@ public override async Task<IEndFeatureMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs
index 421325384..2cc664a97 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs
index 7bcac1eb3..16fc1e917 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EnumerationUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -165,7 +166,7 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -374,9 +375,9 @@ public override IEnumerationUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -745,7 +746,7 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -954,9 +955,9 @@ public override async Task<IEnumerationUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs
index 1c9743b6c..eda61a6f7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/EventOccurrenceUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -166,7 +167,7 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -341,7 +342,7 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -395,9 +396,9 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -708,9 +709,9 @@ public override IEventOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -804,7 +805,7 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -979,7 +980,7 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1033,9 +1034,9 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1346,9 +1347,9 @@ public override async Task<IEventOccurrenceUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs
index fb1b60c54..3c84e9398 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExhibitStateUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -352,7 +353,7 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -406,9 +407,9 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -738,9 +739,9 @@ public override IExhibitStateUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -834,7 +835,7 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1019,7 +1020,7 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1073,9 +1074,9 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1405,9 +1406,9 @@ public override async Task<IExhibitStateUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs
index 656307254..11c659c3a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -143,7 +144,7 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -352,9 +353,9 @@ public override IExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -723,7 +724,7 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -932,9 +933,9 @@ public override async Task<IExpression> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs
index ecd75744f..4fb7128e1 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -360,9 +361,9 @@ public override IFeatureChainExpression Read(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -743,7 +744,7 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -959,9 +960,9 @@ public override async Task<IFeatureChainExpression> ReadAsync(XmlReader xmiReade
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs
index 3a76a5dbf..a3eba6c1e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureChainingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs
index 2b515ff18..26fe15119 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureInvertingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs
index 7c7a6b160..176ea038e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -244,7 +245,7 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -456,9 +457,9 @@ public override IFeatureMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -655,7 +656,7 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -867,9 +868,9 @@ public override async Task<IFeatureMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs
index d7699caf7..f655dbbe5 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -141,7 +142,7 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -350,9 +351,9 @@ public override IFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -721,7 +722,7 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -930,9 +931,9 @@ public override async Task<IFeature> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs
index e60224916..9249aab27 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureReferenceExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -353,9 +354,9 @@ public override IFeatureReferenceExpression Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -724,7 +725,7 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -933,9 +934,9 @@ public override async Task<IFeatureReferenceExpression> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs
index 2005e0ac6..bd8457d6a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureTypingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs
index edffc0280..5e270b278 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FeatureValueReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Kernel.Functions;
@@ -265,7 +266,7 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -515,9 +516,9 @@ public override IFeatureValue Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -734,7 +735,7 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -984,9 +985,9 @@ public override async Task<IFeatureValue> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs
index a441570cc..222560992 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs
index 3cd6a7613..84c2bd036 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowEndReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -142,7 +143,7 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -351,9 +352,9 @@ public override IFlowEnd Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -722,7 +723,7 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -931,9 +932,9 @@ public override async Task<IFlowEnd> ReadAsync(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs
index 1f0e17d83..3ce2915c5 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -146,7 +147,7 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -403,9 +404,9 @@ public override IFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -847,7 +848,7 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1104,9 +1105,9 @@ public override async Task<IFlow> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs
index 58ed9d56c..ba517add3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FlowUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -170,7 +171,7 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -393,7 +394,7 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -447,9 +448,9 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -833,9 +834,9 @@ public override IFlowUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -929,7 +930,7 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1152,7 +1153,7 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1206,9 +1207,9 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1592,9 +1593,9 @@ public override async Task<IFlowUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs
index 2e000c3ff..70a32117b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForLoopActionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IForLoopActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IForLoopActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs
index cb0ed0e26..7a7ed8f78 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ForkNodeReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -342,7 +343,7 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -396,9 +397,9 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -709,9 +710,9 @@ public override IForkNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -805,7 +806,7 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -980,7 +981,7 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1034,9 +1035,9 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1347,9 +1348,9 @@ public override async Task<IForkNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs
index fd79eed39..56e3ac930 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FramedConcernMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.Requirements;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -171,7 +172,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out RequirementConstraintKind kindXmlAttributeAsEnum))
+                    if (RequirementConstraintKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -257,7 +258,7 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -361,9 +362,9 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        if (RequirementConstraintKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -488,9 +489,9 @@ public override IFramedConcernMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -611,7 +612,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out RequirementConstraintKind kindXmlAttributeAsEnum))
+                    if (RequirementConstraintKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -697,7 +698,7 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -801,9 +802,9 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        if (RequirementConstraintKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -928,9 +929,9 @@ public override async Task<IFramedConcernMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs
index e9295a3e4..5fd8a1bb3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/FunctionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs
index 9cf58ac01..e44078083 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IfActionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IIfActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IIfActionUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs
index c290de834..ff480c1f8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IncludeUseCaseUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IIncludeUseCaseUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IIncludeUseCaseUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs
index 08af86790..6d52e4af7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IndexExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -360,9 +361,9 @@ public override IIndexExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -743,7 +744,7 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -959,9 +960,9 @@ public override async Task<IIndexExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs
index 66a84930d..8dad385f3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InteractionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs
index fdb953a87..5ce2b7e32 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs
index 5a344777f..0a856aade 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InterfaceUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -169,7 +170,7 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -392,7 +393,7 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -446,9 +447,9 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -832,9 +833,9 @@ public override IInterfaceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -928,7 +929,7 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1151,7 +1152,7 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1205,9 +1206,9 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1591,9 +1592,9 @@ public override async Task<IInterfaceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs
index f75e35193..017d47e2b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/IntersectingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs
index b2d43e44d..58fb40b42 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvariantReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -143,7 +144,7 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -362,9 +363,9 @@ public override IInvariant Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -752,7 +753,7 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -971,9 +972,9 @@ public override async Task<IInvariant> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs
index 92ff27f2d..df1c1c992 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/InvocationExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -353,9 +354,9 @@ public override IInvocationExpression Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -724,7 +725,7 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -933,9 +934,9 @@ public override async Task<IInvocationExpression> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs
index c6cf0d4c5..5ffe86e99 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs
index df5a9f91f..c7f81216e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ItemUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -342,7 +343,7 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -396,9 +397,9 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -709,9 +710,9 @@ public override IItemUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -805,7 +806,7 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -980,7 +981,7 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1034,9 +1035,9 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1347,9 +1348,9 @@ public override async Task<IItemUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs
index c4ee6bb6e..261324ee4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/JoinNodeReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -342,7 +343,7 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -396,9 +397,9 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -709,9 +710,9 @@ public override IJoinNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -805,7 +806,7 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -980,7 +981,7 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1034,9 +1035,9 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1347,9 +1348,9 @@ public override async Task<IJoinNode> ReadAsync(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs
index 83c058c3a..b0fbaba9c 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LibraryPackageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs
index ae5edfc7a..07f8ac087 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralBooleanReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -363,9 +364,9 @@ public override ILiteralBoolean Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -753,7 +754,7 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -972,9 +973,9 @@ public override async Task<ILiteralBoolean> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs
index c9cff71ab..83e3821ab 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -353,9 +354,9 @@ public override ILiteralExpression Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -724,7 +725,7 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -933,9 +934,9 @@ public override async Task<ILiteralExpression> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs
index 61e2da02e..a580ab317 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralInfinityReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -353,9 +354,9 @@ public override ILiteralInfinity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -724,7 +725,7 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -933,9 +934,9 @@ public override async Task<ILiteralInfinity> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs
index 5a5e91090..e97980cde 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralIntegerReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -363,9 +364,9 @@ public override ILiteralInteger Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -753,7 +754,7 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -972,9 +973,9 @@ public override async Task<ILiteralInteger> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs
index 0da92e43a..b08510e1f 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralRationalReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -363,9 +364,9 @@ public override ILiteralRational Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -753,7 +754,7 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -972,9 +973,9 @@ public override async Task<ILiteralRational> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs
index 34bf6660c..b4264a2d5 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/LiteralStringReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -360,9 +361,9 @@ public override ILiteralString Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -743,7 +744,7 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -959,9 +960,9 @@ public override async Task<ILiteralString> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs
index 30d3ad83f..b4ea09c67 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipExposeReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -277,7 +278,7 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -554,9 +555,9 @@ public override IMembershipExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -787,7 +788,7 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -1064,9 +1065,9 @@ public override async Task<IMembershipExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs
index 24904b3c2..172277f5e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipImportReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -276,7 +277,7 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -553,9 +554,9 @@ public override IMembershipImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -786,7 +787,7 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -1063,9 +1064,9 @@ public override async Task<IMembershipImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs
index 9890089dd..ea4c13313 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -270,7 +271,7 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -533,9 +534,9 @@ public override IMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -760,7 +761,7 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -1023,9 +1024,9 @@ public override async Task<IMembership> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs
index 0031067a3..d1d3a8faf 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MergeNodeReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -342,7 +343,7 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -396,9 +397,9 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -709,9 +710,9 @@ public override IMergeNode Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -805,7 +806,7 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -980,7 +981,7 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1034,9 +1035,9 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1347,9 +1348,9 @@ public override async Task<IMergeNode> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs
index 19a18210a..aaefe6fe6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetaclassReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs
index ec2e5d05b..5d7ba59bb 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataAccessExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -353,9 +354,9 @@ public override IMetadataAccessExpression Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -724,7 +725,7 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -933,9 +934,9 @@ public override async Task<IMetadataAccessExpression> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs
index d73e3ad71..2704b3717 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs
index f8ca84489..631f72b62 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataFeatureReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -142,7 +143,7 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -351,9 +352,9 @@ public override IMetadataFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -722,7 +723,7 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -931,9 +932,9 @@ public override async Task<IMetadataFeature> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs
index 593e76f1a..5c4c43a1b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MetadataUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IMetadataUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IMetadataUsage> ReadAsync(XmlReader xmiReader, Uri cu
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs
index 962680fed..7e51476b2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityRangeReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -143,7 +144,7 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -352,9 +353,9 @@ public override IMultiplicityRange Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -723,7 +724,7 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -932,9 +933,9 @@ public override async Task<IMultiplicityRange> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs
index 4f8ad0aa6..09a466431 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/MultiplicityReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Annotations;
@@ -141,7 +142,7 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -350,9 +351,9 @@ public override IMultiplicity Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -721,7 +722,7 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -930,9 +931,9 @@ public override async Task<IMultiplicity> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs
index 018e53e4f..4fff195f4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceExposeReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -277,7 +278,7 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -554,9 +555,9 @@ public override INamespaceExpose Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -787,7 +788,7 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -1064,9 +1065,9 @@ public override async Task<INamespaceExpose> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs
index 45ff42036..d2e95456e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceImportReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -276,7 +277,7 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -553,9 +554,9 @@ public override INamespaceImport Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -786,7 +787,7 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -1063,9 +1064,9 @@ public override async Task<INamespaceImport> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs
index f728eb5e2..5d09fe3fa 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NamespaceReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs
index 3d831ba69..0d2bdaf75 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/NullExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -353,9 +354,9 @@ public override INullExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -724,7 +725,7 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -933,9 +934,9 @@ public override async Task<INullExpression> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs
index c2c73c217..f6b71acf9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ObjectiveMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -246,7 +247,7 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -458,9 +459,9 @@ public override IObjectiveMembership Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -657,7 +658,7 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -869,9 +870,9 @@ public override async Task<IObjectiveMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs
index 8370b435a..296a44eb3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs
index 51cbef9ca..b02b211e9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OccurrenceUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -166,7 +167,7 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -341,7 +342,7 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -395,9 +396,9 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -708,9 +709,9 @@ public override IOccurrenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -804,7 +805,7 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -979,7 +980,7 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1033,9 +1034,9 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1346,9 +1347,9 @@ public override async Task<IOccurrenceUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs
index 09c5f8b66..0542cc3de 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OperatorExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -360,9 +361,9 @@ public override IOperatorExpression Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -743,7 +744,7 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -959,9 +960,9 @@ public override async Task<IOperatorExpression> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs
index 75b7aee0d..b78e51826 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/OwningMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -242,7 +243,7 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -454,9 +455,9 @@ public override IOwningMembership Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -653,7 +654,7 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -865,9 +866,9 @@ public override async Task<IOwningMembership> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs
index 2f95dbb1e..3c540a2d3 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PackageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs
index b67c4b926..20a4dd4e9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ParameterMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -245,7 +246,7 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -457,9 +458,9 @@ public override IParameterMembership Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -656,7 +657,7 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -868,9 +869,9 @@ public override async Task<IParameterMembership> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs
index af550c2fd..78adf94e7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs
index da340b901..0a889a27e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PartUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -342,7 +343,7 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -396,9 +397,9 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -709,9 +710,9 @@ public override IPartUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -805,7 +806,7 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -980,7 +981,7 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1034,9 +1035,9 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1347,9 +1348,9 @@ public override async Task<IPartUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs
index 418e3359e..438f17d39 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PayloadFeatureReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -142,7 +143,7 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -351,9 +352,9 @@ public override IPayloadFeature Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -722,7 +723,7 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -931,9 +932,9 @@ public override async Task<IPayloadFeature> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs
index d335ba175..55199b615 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PerformActionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -342,7 +343,7 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -396,9 +397,9 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -709,9 +710,9 @@ public override IPerformActionUsage Read(XmlReader xmiReader, Uri currentLocatio
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -805,7 +806,7 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -980,7 +981,7 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1034,9 +1035,9 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1347,9 +1348,9 @@ public override async Task<IPerformActionUsage> ReadAsync(XmlReader xmiReader, U
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs
index daf5f56be..ed4e6dcc8 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortConjugationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs
index 52607da64..c32c72414 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs
index 8d87c8a9a..1b100beaa 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PortUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -166,7 +167,7 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -341,7 +342,7 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -395,9 +396,9 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -708,9 +709,9 @@ public override IPortUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -804,7 +805,7 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -979,7 +980,7 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1033,9 +1034,9 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1346,9 +1347,9 @@ public override async Task<IPortUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs
index ae20c155f..8d2e26b50 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/PredicateReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs
index 2ed78277b..5ec08db8e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RedefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs
index dedcadad6..8d10b222d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceSubsettingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs
index 2bcdc5b25..a0ecc16af 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReferenceUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -164,7 +165,7 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -373,9 +374,9 @@ public override IReferenceUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -744,7 +745,7 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -953,9 +954,9 @@ public override async Task<IReferenceUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs
index dd11cb033..0b1259b38 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs
index 3fb40ed1c..1fd9e6818 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RenderingUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -342,7 +343,7 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -396,9 +397,9 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -709,9 +710,9 @@ public override IRenderingUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -805,7 +806,7 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -980,7 +981,7 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1034,9 +1035,9 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1347,9 +1348,9 @@ public override async Task<IRenderingUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs
index a39cbef2c..282038347 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementConstraintMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.Requirements;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -171,7 +172,7 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out RequirementConstraintKind kindXmlAttributeAsEnum))
+                    if (RequirementConstraintKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -257,7 +258,7 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -361,9 +362,9 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        if (RequirementConstraintKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -488,9 +489,9 @@ public override IRequirementConstraintMembership Read(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -611,7 +612,7 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out RequirementConstraintKind kindXmlAttributeAsEnum))
+                    if (RequirementConstraintKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -697,7 +698,7 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -801,9 +802,9 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        if (RequirementConstraintKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -928,9 +929,9 @@ public override async Task<IRequirementConstraintMembership> ReadAsync(XmlReader
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs
index 0ea9e4747..2f0dc79b1 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs
index 8b33b96c9..1c8e6f491 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -161,7 +162,7 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -336,7 +337,7 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -385,9 +386,9 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -698,9 +699,9 @@ public override IRequirementUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -799,7 +800,7 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -974,7 +975,7 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1023,9 +1024,9 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1336,9 +1337,9 @@ public override async Task<IRequirementUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs
index acd733642..ef3bbab55 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/RequirementVerificationMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.Requirements;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -172,7 +173,7 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out RequirementConstraintKind kindXmlAttributeAsEnum))
+                    if (RequirementConstraintKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -258,7 +259,7 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -362,9 +363,9 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        if (RequirementConstraintKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -489,9 +490,9 @@ public override IRequirementVerificationMembership Read(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -612,7 +613,7 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out RequirementConstraintKind kindXmlAttributeAsEnum))
+                    if (RequirementConstraintKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -698,7 +699,7 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -802,9 +803,9 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(RequirementConstraintKind), kindValue, true, out var kindValueAsEnum))
+                                        if (RequirementConstraintKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (RequirementConstraintKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -929,9 +930,9 @@ public override async Task<IRequirementVerificationMembership> ReadAsync(XmlRead
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs
index 50251258f..80d3193cb 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ResultExpressionMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -245,7 +246,7 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -457,9 +458,9 @@ public override IResultExpressionMembership Read(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -656,7 +657,7 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -868,9 +869,9 @@ public override async Task<IResultExpressionMembership> ReadAsync(XmlReader xmiR
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs
index ef7e2b373..406bb2771 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ReturnParameterMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -246,7 +247,7 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -458,9 +459,9 @@ public override IReturnParameterMembership Read(XmlReader xmiReader, Uri current
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -657,7 +658,7 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -869,9 +870,9 @@ public override async Task<IReturnParameterMembership> ReadAsync(XmlReader xmiRe
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs
index 80b8eaae6..67bd016a4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SatisfyRequirementUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -161,7 +162,7 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -346,7 +347,7 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -395,9 +396,9 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -727,9 +728,9 @@ public override ISatisfyRequirementUsage Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -828,7 +829,7 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1013,7 +1014,7 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1062,9 +1063,9 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1394,9 +1395,9 @@ public override async Task<ISatisfyRequirementUsage> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs
index 4775601ae..5368ea304 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SelectExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -144,7 +145,7 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -360,9 +361,9 @@ public override ISelectExpression Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -743,7 +744,7 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -959,9 +960,9 @@ public override async Task<ISelectExpression> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs
index bfa15b85c..756737ad0 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SendActionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override ISendActionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<ISendActionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs
index ace40f6bd..eb6c89273 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SpecializationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs
index ff8d75114..37b96d7c0 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StakeholderMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -247,7 +248,7 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -459,9 +460,9 @@ public override IStakeholderMembership Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -658,7 +659,7 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -870,9 +871,9 @@ public override async Task<IStakeholderMembership> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs
index 5f95c81f3..6032af5c7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs
index 2431ba0e8..434e6de8b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateSubactionMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.States;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -171,7 +172,7 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out StateSubactionKind kindXmlAttributeAsEnum))
+                    if (StateSubactionKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -257,7 +258,7 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -361,9 +362,9 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(StateSubactionKind), kindValue, true, out var kindValueAsEnum))
+                                        if (StateSubactionKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (StateSubactionKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -488,9 +489,9 @@ public override IStateSubactionMembership Read(XmlReader xmiReader, Uri currentL
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -611,7 +612,7 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out StateSubactionKind kindXmlAttributeAsEnum))
+                    if (StateSubactionKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -697,7 +698,7 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -801,9 +802,9 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(StateSubactionKind), kindValue, true, out var kindValueAsEnum))
+                                        if (StateSubactionKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (StateSubactionKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -928,9 +929,9 @@ public override async Task<IStateSubactionMembership> ReadAsync(XmlReader xmiRea
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs
index c5f6ac0a0..dfd2c8e5d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StateUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -167,7 +168,7 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -352,7 +353,7 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -406,9 +407,9 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -738,9 +739,9 @@ public override IStateUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -834,7 +835,7 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1019,7 +1020,7 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1073,9 +1074,9 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1405,9 +1406,9 @@ public override async Task<IStateUsage> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs
index fc67aa991..4d02effb6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StepReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -142,7 +143,7 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -351,9 +352,9 @@ public override IStep Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -722,7 +723,7 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -931,9 +932,9 @@ public override async Task<IStep> ReadAsync(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs
index e2cf72fec..cdc2ec746 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/StructureReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs
index 488981a00..441c66d7b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubclassificationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs
index 31971fc60..fb6af79c2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubjectMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -247,7 +248,7 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -459,9 +460,9 @@ public override ISubjectMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -658,7 +659,7 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -870,9 +871,9 @@ public override async Task<ISubjectMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs
index 655c624bf..d88f9ed4e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SubsettingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs
index bfa60ebfe..fe02f36d6 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionAsUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -166,7 +167,7 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -423,9 +424,9 @@ public override ISuccessionAsUsage Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -867,7 +868,7 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1124,9 +1125,9 @@ public override async Task<ISuccessionAsUsage> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs
index 4ef0c2686..1eaf380c1 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -146,7 +147,7 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -403,9 +404,9 @@ public override ISuccessionFlow Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -847,7 +848,7 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1104,9 +1105,9 @@ public override async Task<ISuccessionFlow> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs
index fdf7bb0f5..6814fc8eb 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionFlowUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -170,7 +171,7 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -393,7 +394,7 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -447,9 +448,9 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -833,9 +834,9 @@ public override ISuccessionFlowUsage Read(XmlReader xmiReader, Uri currentLocati
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -929,7 +930,7 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1152,7 +1153,7 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1206,9 +1207,9 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1592,9 +1593,9 @@ public override async Task<ISuccessionFlowUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs
index bec906b67..e46703d1b 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/SuccessionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -143,7 +144,7 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -400,9 +401,9 @@ public override ISuccession Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -844,7 +845,7 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -1101,9 +1102,9 @@ public override async Task<ISuccession> ReadAsync(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs
index c538acf8a..ebb65b293 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TerminateActionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override ITerminateActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<ITerminateActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs
index e7cfeb3a7..7e84e4777 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TextualRepresentationReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs
index 54fbeab58..69968df2a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionFeatureMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.Systems.States;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -171,7 +172,7 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out TransitionFeatureKind kindXmlAttributeAsEnum))
+                    if (TransitionFeatureKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -257,7 +258,7 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -361,9 +362,9 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(TransitionFeatureKind), kindValue, true, out var kindValueAsEnum))
+                                        if (TransitionFeatureKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (TransitionFeatureKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -488,9 +489,9 @@ public override ITransitionFeatureMembership Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -611,7 +612,7 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out TransitionFeatureKind kindXmlAttributeAsEnum))
+                    if (TransitionFeatureKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -697,7 +698,7 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -801,9 +802,9 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(TransitionFeatureKind), kindValue, true, out var kindValueAsEnum))
+                                        if (TransitionFeatureKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (TransitionFeatureKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -928,9 +929,9 @@ public override async Task<ITransitionFeatureMembership> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs
index 84630f4fb..8cc9f924a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TransitionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -169,7 +170,7 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -344,7 +345,7 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -398,9 +399,9 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -711,9 +712,9 @@ public override ITransitionUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -807,7 +808,7 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -982,7 +983,7 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1036,9 +1037,9 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1349,9 +1350,9 @@ public override async Task<ITransitionUsage> ReadAsync(XmlReader xmiReader, Uri
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs
index b57c46dd8..a4c9e8268 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TriggerInvocationExpressionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Actions;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -146,7 +147,7 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -273,7 +274,7 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out TriggerKind kindXmlAttributeAsEnum))
+                    if (TriggerKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -365,9 +366,9 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -605,9 +606,9 @@ public override ITriggerInvocationExpression Read(XmlReader xmiReader, Uri curre
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(TriggerKind), kindValue, true, out var kindValueAsEnum))
+                                        if (TriggerKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (TriggerKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
@@ -755,7 +756,7 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -882,7 +883,7 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                 if (!string.IsNullOrWhiteSpace(kindXmlAttribute))
                 {
-                    if (Enum.TryParse(kindXmlAttribute, true, out TriggerKind kindXmlAttributeAsEnum))
+                    if (TriggerKindProvider.TryParse(kindXmlAttribute.AsSpan(), out var kindXmlAttributeAsEnum))
                     {
                         poco.Kind = kindXmlAttributeAsEnum;
                     }
@@ -974,9 +975,9 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1214,9 +1215,9 @@ public override async Task<ITriggerInvocationExpression> ReadAsync(XmlReader xmi
 
                                     if (!string.IsNullOrWhiteSpace(kindValue))
                                     {
-                                        if (Enum.TryParse(typeof(TriggerKind), kindValue, true, out var kindValueAsEnum))
+                                        if (TriggerKindProvider.TryParse(kindValue.AsSpan(), out var kindValueAsEnum))
                                         {
-                                            poco.Kind = (TriggerKind)kindValueAsEnum;
+                                            poco.Kind = kindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs
index 6d26aecdf..318b5b3da 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeFeaturingReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Types;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs
index e807265c1..f73316b15 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/TypeReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs
index 2cc8ba40f..d8de398c7 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UnioningReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs
index 7d5179a64..c5d989531 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
@@ -164,7 +165,7 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -373,9 +374,9 @@ public override IUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -744,7 +745,7 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -953,9 +954,9 @@ public override async Task<IUsage> ReadAsync(XmlReader xmiReader, Uri currentLoc
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs
index 109dde1d2..314ec9ed9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs
index 840b31436..f6865c7d4 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/UseCaseUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IUseCaseUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IUseCaseUsage> ReadAsync(XmlReader xmiReader, Uri cur
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs
index 7894b094d..f2d1dd050 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VariantMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -243,7 +244,7 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -455,9 +456,9 @@ public override IVariantMembership Read(XmlReader xmiReader, Uri currentLocation
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -654,7 +655,7 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -866,9 +867,9 @@ public override async Task<IVariantMembership> ReadAsync(XmlReader xmiReader, Ur
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs
index f7e37695c..bc8428eb9 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs
index 8004a6243..1b2bc075a 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/VerificationCaseUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IVerificationCaseUsage Read(XmlReader xmiReader, Uri currentLoca
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IVerificationCaseUsage> ReadAsync(XmlReader xmiReader
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs
index e5bd9ce6f..2cac3d9d2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs
index 9c4b494e8..1a98b1186 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewRenderingMembershipReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
@@ -245,7 +246,7 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -457,9 +458,9 @@ public override IViewRenderingMembership Read(XmlReader xmiReader, Uri currentLo
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
@@ -656,7 +657,7 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
 
                 if (!string.IsNullOrWhiteSpace(visibilityXmlAttribute))
                 {
-                    if (Enum.TryParse(visibilityXmlAttribute, true, out VisibilityKind visibilityXmlAttributeAsEnum))
+                    if (VisibilityKindProvider.TryParse(visibilityXmlAttribute.AsSpan(), out var visibilityXmlAttributeAsEnum))
                     {
                         poco.Visibility = visibilityXmlAttributeAsEnum;
                     }
@@ -868,9 +869,9 @@ public override async Task<IViewRenderingMembership> ReadAsync(XmlReader xmiRead
 
                                     if (!string.IsNullOrWhiteSpace(visibilityValue))
                                     {
-                                        if (Enum.TryParse(typeof(VisibilityKind), visibilityValue, true, out var visibilityValueAsEnum))
+                                        if (VisibilityKindProvider.TryParse(visibilityValue.AsSpan(), out var visibilityValueAsEnum))
                                         {
-                                            poco.Visibility = (VisibilityKind)visibilityValueAsEnum;
+                                            poco.Visibility = visibilityValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs
index 90e70f170..1257941f2 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IViewUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IViewUsage> ReadAsync(XmlReader xmiReader, Uri curren
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs
index c16812481..b5093a24d 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointDefinitionReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Core.Types;
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs
index e5fa4a6a6..33962869e 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/ViewpointUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -161,7 +162,7 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -336,7 +337,7 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -385,9 +386,9 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -698,9 +699,9 @@ public override IViewpointUsage Read(XmlReader xmiReader, Uri currentLocation)
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -799,7 +800,7 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -974,7 +975,7 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1023,9 +1024,9 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1336,9 +1337,9 @@ public override async Task<IViewpointUsage> ReadAsync(XmlReader xmiReader, Uri c
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
diff --git a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs
index 3bc1984dc..b8ff88716 100644
--- a/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs
+++ b/SysML2.NET.Serializer.Xmi/Readers/AutoGenReaders/WhileLoopActionUsageReader.cs
@@ -33,6 +33,7 @@ namespace SysML2.NET.Serializer.Xmi.Readers
     using Microsoft.Extensions.Logging.Abstractions;
 
     using SysML2.NET.Common;
+    using SysML2.NET.Extensions.Core;
     using SysML2.NET.Core.Core.Types;
     using SysML2.NET.Core.Systems.Occurrences;
     using SysML2.NET.Core.POCO.Core.Classifiers;
@@ -168,7 +169,7 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -343,7 +344,7 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -397,9 +398,9 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -710,9 +711,9 @@ public override IWhileLoopActionUsage Read(XmlReader xmiReader, Uri currentLocat
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {
@@ -806,7 +807,7 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(directionXmlAttribute))
                 {
-                    if (Enum.TryParse(directionXmlAttribute, true, out FeatureDirectionKind directionXmlAttributeAsEnum))
+                    if (FeatureDirectionKindProvider.TryParse(directionXmlAttribute.AsSpan(), out var directionXmlAttributeAsEnum))
                     {
                         poco.Direction = directionXmlAttributeAsEnum;
                     }
@@ -981,7 +982,7 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                 if (!string.IsNullOrWhiteSpace(portionKindXmlAttribute))
                 {
-                    if (Enum.TryParse(portionKindXmlAttribute, true, out PortionKind portionKindXmlAttributeAsEnum))
+                    if (PortionKindProvider.TryParse(portionKindXmlAttribute.AsSpan(), out var portionKindXmlAttributeAsEnum))
                     {
                         poco.PortionKind = portionKindXmlAttributeAsEnum;
                     }
@@ -1035,9 +1036,9 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(directionValue))
                                     {
-                                        if (Enum.TryParse(typeof(FeatureDirectionKind), directionValue, true, out var directionValueAsEnum))
+                                        if (FeatureDirectionKindProvider.TryParse(directionValue.AsSpan(), out var directionValueAsEnum))
                                         {
-                                            poco.Direction = (FeatureDirectionKind)directionValueAsEnum;
+                                            poco.Direction = directionValueAsEnum;
                                         }
                                         else
                                         {
@@ -1348,9 +1349,9 @@ public override async Task<IWhileLoopActionUsage> ReadAsync(XmlReader xmiReader,
 
                                     if (!string.IsNullOrWhiteSpace(portionKindValue))
                                     {
-                                        if (Enum.TryParse(typeof(PortionKind), portionKindValue, true, out var portionKindValueAsEnum))
+                                        if (PortionKindProvider.TryParse(portionKindValue.AsSpan(), out var portionKindValueAsEnum))
                                         {
-                                            poco.PortionKind = (PortionKind)portionKindValueAsEnum;
+                                            poco.PortionKind = portionKindValueAsEnum;
                                         }
                                         else
                                         {

From 30daa831eccc06ae02ffeb3579828604e54cab17 Mon Sep 17 00:00:00 2001
From: samatstarion <s.gerene@stariongroup.eu>
Date: Sat, 21 Mar 2026 17:42:51 +0100
Subject: [PATCH 9/9] [Simplify] Xmi Serializer and DeSerializer

---
 .../DeSerializerTestFixture.cs                |  6 +--
 .../RoundTripTestFixture.cs                   | 39 ++++---------------
 .../SerializerTestFixture.cs                  | 12 ++----
 SysML2.NET.Serializer.Xmi/DeSerializer.cs     | 39 +++++++++----------
 SysML2.NET.Serializer.Xmi/Serializer.cs       | 16 +++-----
 5 files changed, 34 insertions(+), 78 deletions(-)

diff --git a/SysML2.NET.Serializer.Xmi.Tests/DeSerializerTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/DeSerializerTestFixture.cs
index b238c8675..39dc082a1 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/DeSerializerTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/DeSerializerTestFixture.cs
@@ -29,13 +29,11 @@ namespace SysML2.NET.Serializer.Xmi.Tests
     using Microsoft.Extensions.Logging;
 
     using SysML2.NET.Serializer.Xmi.Extensions;
-    using SysML2.NET.Serializer.Xmi.Readers;
 
     [TestFixture]
     public class DeSerializerTestFixture
     {
         private DeSerializer deSerializer;
-        private XmiDataCache xmiDataCache;
 
         [SetUp]
         public void Setup()
@@ -44,9 +42,7 @@ public void Setup()
                 .AddLogging(x => x.AddConsole())
                 .BuildServiceProvider();
 
-            this.xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(),serviceProvider.GetRequiredService<ILogger<XmiDataCache>>());
-
-            this.deSerializer = new DeSerializer(new ExternalReferenceService(serviceProvider.GetRequiredService<ILogger<ExternalReferenceService>>()), new XmiDataReaderFacade(), this.xmiDataCache, serviceProvider.GetRequiredService<ILoggerFactory>());
+            this.deSerializer = new DeSerializer(serviceProvider.GetRequiredService<ILoggerFactory>());
         }
 
         [Test]
diff --git a/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
index a1effe518..ad31a1069 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/RoundTripTestFixture.cs
@@ -31,14 +31,13 @@ namespace SysML2.NET.Serializer.Xmi.Tests
     using Org.XmlUnit.Builder;
     using Org.XmlUnit.Diff;
 
-    using SysML2.NET.Serializer.Xmi.Extensions;
-    using SysML2.NET.Serializer.Xmi.Readers;
     using SysML2.NET.Serializer.Xmi.Writers;
 
     [TestFixture]
     public class RoundTripTestFixture
     {
         private ILoggerFactory loggerFactory;
+        
         private XmiWriterOptions writerOptions = new();
 
         [SetUp]
@@ -54,13 +53,7 @@ public void Setup()
         [Test]
         public void Verify_that_deserialization_with_origin_map_tracks_elements()
         {
-            var xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
-            
-            var deSerializer = new DeSerializer(
-                new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
-                new XmiDataReaderFacade(),
-                xmiDataCache,
-                this.loggerFactory);
+            var deSerializer = new DeSerializer(this.loggerFactory);
 
             var originMap = new XmiElementOriginMap();
 
@@ -89,13 +82,7 @@ public void Verify_that_deserialization_with_origin_map_tracks_elements()
         public void Verify_that_serialized_output_is_well_formed_xml_with_correct_root()
         {
             // Step 1: Deserialize original
-            var xmiDataCache1 = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
-            
-            var deSerializer1 = new DeSerializer(
-                new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
-                new XmiDataReaderFacade(),
-                xmiDataCache1,
-                this.loggerFactory);
+            var deSerializer1 = new DeSerializer(this.loggerFactory);
 
             var filePath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "Domain Libraries", "Quantities and Units", "Quantities.sysmlx");
             var originalNamespace = deSerializer1.DeSerialize(new Uri(filePath));
@@ -103,7 +90,7 @@ public void Verify_that_serialized_output_is_well_formed_xml_with_correct_root()
             Assert.That(originalNamespace, Is.Not.Null);
 
             // Step 2: Serialize to stream
-            var serializer = new Serializer(new XmiDataWriterFacade(this.loggerFactory), this.loggerFactory);
+            var serializer = new Serializer(this.loggerFactory);
             var memoryStream = new MemoryStream();
 
             serializer.Serialize(originalNamespace, this.writerOptions, memoryStream);
@@ -129,13 +116,7 @@ public void Verify_that_serialized_output_is_well_formed_xml_with_correct_root()
         [Test]
         public void Verify_that_origin_map_captures_multi_file_references()
         {
-            var xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
-            
-            var deSerializer = new DeSerializer(
-                new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
-                new XmiDataReaderFacade(),
-                xmiDataCache,
-                this.loggerFactory);
+            var deSerializer = new DeSerializer(this.loggerFactory);
 
             var originMap = new XmiElementOriginMap();
 
@@ -161,13 +142,7 @@ public void Verify_that_origin_map_captures_multi_file_references()
         [Test]
         public void VerifySerializedXmlCorrespondToOriginalFile()
         {
-            var xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
-            
-            var deSerializer = new DeSerializer(
-                new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>()),
-                new XmiDataReaderFacade(),
-                xmiDataCache,
-                this.loggerFactory);
+            var deSerializer = new DeSerializer(this.loggerFactory);
 
             var originMap = new XmiElementOriginMap();
 
@@ -177,7 +152,7 @@ public void VerifySerializedXmlCorrespondToOriginalFile()
 
             var quantityNamespace = deSerializer.DeSerialize(fileUri, originMap);
             
-            var serializer = new Serializer(new XmiDataWriterFacade(this.loggerFactory), this.loggerFactory);
+            var serializer = new Serializer(this.loggerFactory);
             var outputFile = Path.Combine(TestContext.CurrentContext.TestDirectory, "SerializedQuantities.sysmlx");
             
             var fileStream = new FileStream(outputFile, FileMode.Create);
diff --git a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
index 11843b36a..63c2f4142 100644
--- a/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
+++ b/SysML2.NET.Serializer.Xmi.Tests/SerializerTestFixture.cs
@@ -26,14 +26,11 @@ namespace SysML2.NET.Serializer.Xmi.Tests
     using System.Threading;
     using System.Threading.Tasks;
 
-    using Core.POCO.Root.Elements;
     using Core.POCO.Root.Namespaces;
 
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.Logging;
 
-    using SysML2.NET.Serializer.Xmi.Extensions;
-    using SysML2.NET.Serializer.Xmi.Readers;
     using SysML2.NET.Serializer.Xmi.Writers;
 
     [TestFixture]
@@ -41,8 +38,7 @@ public class SerializerTestFixture
     {
         private Serializer serializer;
         private DeSerializer deSerializer;
-        private XmiDataCache xmiDataCache;
-
+        
         private INamespace anonymouseNameSpace;
         private XmiWriterOptions writerOptions = new();
         
@@ -53,13 +49,11 @@ public void Setup()
                 .AddLogging(x => x.AddConsole())
                 .BuildServiceProvider();
 
-            this.xmiDataCache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), serviceProvider.GetRequiredService<ILogger<XmiDataCache>>());
-
-            this.deSerializer = new DeSerializer(new ExternalReferenceService(serviceProvider.GetRequiredService<ILogger<ExternalReferenceService>>()), new XmiDataReaderFacade(), this.xmiDataCache, serviceProvider.GetRequiredService<ILoggerFactory>());
+            this.deSerializer = new DeSerializer(serviceProvider.GetRequiredService<ILoggerFactory>());
 
             this.ReadAndAssemblePopulationFromXmiFile();
 
-            this.serializer = new Serializer(new XmiDataWriterFacade(serviceProvider.GetRequiredService<ILoggerFactory>()), serviceProvider.GetRequiredService<ILoggerFactory>());
+            this.serializer = new Serializer(serviceProvider.GetRequiredService<ILoggerFactory>());
         }
 
         [Test]
diff --git a/SysML2.NET.Serializer.Xmi/DeSerializer.cs b/SysML2.NET.Serializer.Xmi/DeSerializer.cs
index 14386c640..116df4aba 100644
--- a/SysML2.NET.Serializer.Xmi/DeSerializer.cs
+++ b/SysML2.NET.Serializer.Xmi/DeSerializer.cs
@@ -33,8 +33,9 @@ namespace SysML2.NET.Serializer.Xmi
 
     using SysML2.NET.Common;
     using SysML2.NET.Core.POCO.Root.Namespaces;
+    using SysML2.NET.Serializer.Xmi.Extensions;
     using SysML2.NET.Serializer.Xmi.Readers;
-
+    
     /// <summary>
     /// The purpose of the <see cref="DeSerializer" /> is to deserialize a XMI <see cref="Stream" /> to
     /// an <see cref="IData" /> and <see cref="IEnumerable{IData}" />
@@ -42,45 +43,41 @@ namespace SysML2.NET.Serializer.Xmi
     public class DeSerializer : IDeSerializer
     {
         /// <summary>
-        /// The injected <see cref="IXmiDataCache" /> storing read <see cref="IData" />
+        /// The injected <see cref="ILogger{TCategoryName}" /> to produce logs statement
         /// </summary>
-        private readonly IXmiDataCache cache;
+        private readonly ILogger<DeSerializer> logger;
 
         /// <summary>
-        /// The injected <see cref="IExternalReferenceService" /> providing external reference file resolve
+        /// The injected <see cref="ILoggerFactory " /> used to set up logging
         /// </summary>
-        private readonly IExternalReferenceService externalReferenceService;
-
+        private readonly ILoggerFactory loggerFactory;
+        
         /// <summary>
-        /// The injected <see cref="ILogger{TCategoryName}" /> to produce logs statement
+        /// The injected <see cref="IXmiDataCache" /> storing read <see cref="IData" />
         /// </summary>
-        private readonly ILogger<DeSerializer> logger;
+        private readonly XmiDataCache cache;
 
         /// <summary>
-        /// The injected <see cref="ILoggerFactory " /> used to set up logging
+        /// The injected <see cref="IExternalReferenceService" /> providing external reference file resolve
         /// </summary>
-        private readonly ILoggerFactory loggerFactory;
+        private readonly ExternalReferenceService externalReferenceService;
 
         /// <summary>
         /// The injected <see cref="IXmiDataReaderFacade" /> providing <see cref="XmiDataReader{TData}" /> resolve feature based on XMI row type
         /// </summary>
-        private readonly IXmiDataReaderFacade xmiDataReaderFacade;
+        private readonly XmiDataReaderFacade xmiDataReaderFacade;
 
         /// <summary>Initializes a new instance of the <see cref="DeSerializer"></see> class.</summary>
-        /// <param name="externalReferenceService">The injected <see cref="IExternalReferenceService" /> providing external reference file resolve</param>
-        /// <param name="xmiDataReaderFacade">
-        /// The injected <see cref="IXmiDataReaderFacade" /> providing
-        /// <see cref="XmiDataReader{TData}" /> resolve feature based on XMI row type
-        /// </param>
-        /// <param name="cache">The injected <see cref="IXmiDataCache" /> storing read <see cref="IData" /></param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory " /> used to set up logging</param>
-        public DeSerializer(IExternalReferenceService externalReferenceService, IXmiDataReaderFacade xmiDataReaderFacade, IXmiDataCache cache, ILoggerFactory loggerFactory)
+        public DeSerializer(ILoggerFactory loggerFactory)
         {
             this.loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
             this.logger = this.loggerFactory.CreateLogger<DeSerializer>();
-            this.cache = cache;
-            this.externalReferenceService = externalReferenceService;
-            this.xmiDataReaderFacade = xmiDataReaderFacade;
+            
+            this.externalReferenceService = new ExternalReferenceService(this.loggerFactory.CreateLogger<ExternalReferenceService>());
+            this.cache = new XmiDataCache(new PocoReferenceResolveExtensionsFacade(), this.loggerFactory.CreateLogger<XmiDataCache>());
+            
+            this.xmiDataReaderFacade = new XmiDataReaderFacade();
         }
 
         /// <summary>
diff --git a/SysML2.NET.Serializer.Xmi/Serializer.cs b/SysML2.NET.Serializer.Xmi/Serializer.cs
index e082e05bf..e2fe5c629 100644
--- a/SysML2.NET.Serializer.Xmi/Serializer.cs
+++ b/SysML2.NET.Serializer.Xmi/Serializer.cs
@@ -61,24 +61,18 @@ public class Serializer : ISerializer
         /// </summary>
         private readonly ILogger<Serializer> logger;
         
-        /// <summary>
-        /// Gets the <see cref="ILoggerFactory"/> instance used to set up logging
-        /// </summary>
-        private readonly ILoggerFactory loggerFactory;
-        
         /// <summary>
         /// Gets the <see cref="IXmiDataWriterFacade"/> to dispatch <see cref="IElement"/> writing
         /// </summary>
-        private readonly IXmiDataWriterFacade xmiWriterFacade;
+        private readonly XmiDataWriterFacade xmiWriterFacade;
 
         /// <summary>Initializes a new instance of the <see cref="Serializer"></see> class.</summary>
-        /// <param name="xmiWriterFacade">The injected <see cref="IXmiDataWriterFacade"/> to dispatch element writing</param>
         /// <param name="loggerFactory">The injected <see cref="ILoggerFactory " /> used to set up logging</param>
-        public Serializer(IXmiDataWriterFacade xmiWriterFacade, ILoggerFactory loggerFactory)
+        public Serializer(ILoggerFactory loggerFactory)
         {
-            this.loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
-            this.logger = this.loggerFactory.CreateLogger<Serializer>();
-            this.xmiWriterFacade = xmiWriterFacade ?? throw new ArgumentNullException(nameof(xmiWriterFacade));
+            this.logger = loggerFactory.CreateLogger<Serializer>();
+            
+            this.xmiWriterFacade = new XmiDataWriterFacade(loggerFactory);
         }
 
         /// <summary>